Subversion Repositories SmartDukaan

Rev

Rev 8616 | Rev 8739 | 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 
 
8619 kshitij.so 896 
 
5944 mandeep.dh 897 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
898 
  def __init__(self, iprot, oprot=None):
899 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
900 
 
901 
  def addItem(self, item):
902 
    """
903 
    Availability and inventory attributes
904 
 
905 
    Parameters:
906 
     - item
907 
    """
908 
    self.send_addItem(item)
909 
    return self.recv_addItem()
910 
 
911 
  def send_addItem(self, item):
912 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
913 
    args = addItem_args()
914 
    args.item = item
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_addItem(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = addItem_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
929 
    if result.success is not None:
930 
      return result.success
931 
    if result.cex is not None:
932 
      raise result.cex
933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
934 
 
935 
  def updateItem(self, item):
936 
    """
937 
    Parameters:
938 
     - item
939 
    """
940 
    self.send_updateItem(item)
941 
    return self.recv_updateItem()
942 
 
943 
  def send_updateItem(self, item):
944 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
945 
    args = updateItem_args()
946 
    args.item = item
947 
    args.write(self._oprot)
948 
    self._oprot.writeMessageEnd()
949 
    self._oprot.trans.flush()
950 
 
951 
  def recv_updateItem(self, ):
952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
953 
    if mtype == TMessageType.EXCEPTION:
954 
      x = TApplicationException()
955 
      x.read(self._iprot)
956 
      self._iprot.readMessageEnd()
957 
      raise x
958 
    result = updateItem_result()
959 
    result.read(self._iprot)
960 
    self._iprot.readMessageEnd()
961 
    if result.success is not None:
962 
      return result.success
963 
    if result.cex is not None:
964 
      raise result.cex
965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
966 
 
967 
  def isActive(self, itemId):
968 
    """
969 
    Checks if the item given to the corresponding itemId is active. If it's active,
970 
    whether it's risky and if it's risky, its inventory position.
971 
 
972 
    Parameters:
973 
     - itemId
974 
    """
975 
    self.send_isActive(itemId)
976 
    return self.recv_isActive()
977 
 
978 
  def send_isActive(self, itemId):
979 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
980 
    args = isActive_args()
981 
    args.itemId = itemId
982 
    args.write(self._oprot)
983 
    self._oprot.writeMessageEnd()
984 
    self._oprot.trans.flush()
985 
 
986 
  def recv_isActive(self, ):
987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
988 
    if mtype == TMessageType.EXCEPTION:
989 
      x = TApplicationException()
990 
      x.read(self._iprot)
991 
      self._iprot.readMessageEnd()
992 
      raise x
993 
    result = isActive_result()
994 
    result.read(self._iprot)
995 
    self._iprot.readMessageEnd()
996 
    if result.success is not None:
997 
      return result.success
998 
    if result.isex is not None:
999 
      raise result.isex
1000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1001 
 
7438 amit.gupta 1002 
  def getItemsStatus(self, itemIds):
1003 
    """
1004 
    Parameters:
1005 
     - itemIds
1006 
    """
1007 
    self.send_getItemsStatus(itemIds)
1008 
    return self.recv_getItemsStatus()
1009 
 
1010 
  def send_getItemsStatus(self, itemIds):
1011 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1012 
    args = getItemsStatus_args()
1013 
    args.itemIds = itemIds
1014 
    args.write(self._oprot)
1015 
    self._oprot.writeMessageEnd()
1016 
    self._oprot.trans.flush()
1017 
 
1018 
  def recv_getItemsStatus(self, ):
1019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1020 
    if mtype == TMessageType.EXCEPTION:
1021 
      x = TApplicationException()
1022 
      x.read(self._iprot)
1023 
      self._iprot.readMessageEnd()
1024 
      raise x
1025 
    result = getItemsStatus_result()
1026 
    result.read(self._iprot)
1027 
    self._iprot.readMessageEnd()
1028 
    if result.success is not None:
1029 
      return result.success
1030 
    if result.isex is not None:
1031 
      raise result.isex
1032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1033 
 
5944 mandeep.dh 1034 
  def getItemStatusDescription(self, itemId):
1035 
    """
1036 
    Parameters:
1037 
     - itemId
1038 
    """
1039 
    self.send_getItemStatusDescription(itemId)
1040 
    return self.recv_getItemStatusDescription()
1041 
 
1042 
  def send_getItemStatusDescription(self, itemId):
1043 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1044 
    args = getItemStatusDescription_args()
1045 
    args.itemId = itemId
1046 
    args.write(self._oprot)
1047 
    self._oprot.writeMessageEnd()
1048 
    self._oprot.trans.flush()
1049 
 
1050 
  def recv_getItemStatusDescription(self, ):
1051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1052 
    if mtype == TMessageType.EXCEPTION:
1053 
      x = TApplicationException()
1054 
      x.read(self._iprot)
1055 
      self._iprot.readMessageEnd()
1056 
      raise x
1057 
    result = getItemStatusDescription_result()
1058 
    result.read(self._iprot)
1059 
    self._iprot.readMessageEnd()
1060 
    if result.success is not None:
1061 
      return result.success
1062 
    if result.isex is not None:
1063 
      raise result.isex
1064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1065 
 
1066 
  def startItemOn(self, item_id, timestamp):
1067 
    """
1068 
    Parameters:
1069 
     - item_id
1070 
     - timestamp
1071 
    """
1072 
    self.send_startItemOn(item_id, timestamp)
1073 
    self.recv_startItemOn()
1074 
 
1075 
  def send_startItemOn(self, item_id, timestamp):
1076 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1077 
    args = startItemOn_args()
1078 
    args.item_id = item_id
1079 
    args.timestamp = timestamp
1080 
    args.write(self._oprot)
1081 
    self._oprot.writeMessageEnd()
1082 
    self._oprot.trans.flush()
1083 
 
1084 
  def recv_startItemOn(self, ):
1085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1086 
    if mtype == TMessageType.EXCEPTION:
1087 
      x = TApplicationException()
1088 
      x.read(self._iprot)
1089 
      self._iprot.readMessageEnd()
1090 
      raise x
1091 
    result = startItemOn_result()
1092 
    result.read(self._iprot)
1093 
    self._iprot.readMessageEnd()
1094 
    if result.cex is not None:
1095 
      raise result.cex
1096 
    return
1097 
 
1098 
  def retireItemOn(self, item_id, timestamp):
1099 
    """
1100 
    Parameters:
1101 
     - item_id
1102 
     - timestamp
1103 
    """
1104 
    self.send_retireItemOn(item_id, timestamp)
1105 
    self.recv_retireItemOn()
1106 
 
1107 
  def send_retireItemOn(self, item_id, timestamp):
1108 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1109 
    args = retireItemOn_args()
1110 
    args.item_id = item_id
1111 
    args.timestamp = timestamp
1112 
    args.write(self._oprot)
1113 
    self._oprot.writeMessageEnd()
1114 
    self._oprot.trans.flush()
1115 
 
1116 
  def recv_retireItemOn(self, ):
1117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1118 
    if mtype == TMessageType.EXCEPTION:
1119 
      x = TApplicationException()
1120 
      x.read(self._iprot)
1121 
      self._iprot.readMessageEnd()
1122 
      raise x
1123 
    result = retireItemOn_result()
1124 
    result.read(self._iprot)
1125 
    self._iprot.readMessageEnd()
1126 
    if result.cex is not None:
1127 
      raise result.cex
1128 
    return
1129 
 
1130 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1131 
    """
1132 
    Parameters:
1133 
     - item_id
1134 
     - timestamp
1135 
     - newstatus
1136 
    """
1137 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1138 
    self.recv_changeItemStatus()
1139 
 
1140 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1141 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1142 
    args = changeItemStatus_args()
1143 
    args.item_id = item_id
1144 
    args.timestamp = timestamp
1145 
    args.newstatus = newstatus
1146 
    args.write(self._oprot)
1147 
    self._oprot.writeMessageEnd()
1148 
    self._oprot.trans.flush()
1149 
 
1150 
  def recv_changeItemStatus(self, ):
1151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1152 
    if mtype == TMessageType.EXCEPTION:
1153 
      x = TApplicationException()
1154 
      x.read(self._iprot)
1155 
      self._iprot.readMessageEnd()
1156 
      raise x
1157 
    result = changeItemStatus_result()
1158 
    result.read(self._iprot)
1159 
    self._iprot.readMessageEnd()
1160 
    if result.cex is not None:
1161 
      raise result.cex
1162 
    return
1163 
 
1164 
  def getItem(self, item_id):
1165 
    """
1166 
    Parameters:
1167 
     - item_id
1168 
    """
1169 
    self.send_getItem(item_id)
1170 
    return self.recv_getItem()
1171 
 
1172 
  def send_getItem(self, item_id):
1173 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1174 
    args = getItem_args()
1175 
    args.item_id = item_id
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1180 
  def recv_getItem(self, ):
1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1187 
    result = getItem_result()
1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
1190 
    if result.success is not None:
1191 
      return result.success
1192 
    if result.cex is not None:
1193 
      raise result.cex
1194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1195 
 
1196 
  def getItemsByCatalogId(self, catalog_item_id):
1197 
    """
1198 
    Parameters:
1199 
     - catalog_item_id
1200 
    """
1201 
    self.send_getItemsByCatalogId(catalog_item_id)
1202 
    return self.recv_getItemsByCatalogId()
1203 
 
1204 
  def send_getItemsByCatalogId(self, catalog_item_id):
1205 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1206 
    args = getItemsByCatalogId_args()
1207 
    args.catalog_item_id = catalog_item_id
1208 
    args.write(self._oprot)
1209 
    self._oprot.writeMessageEnd()
1210 
    self._oprot.trans.flush()
1211 
 
1212 
  def recv_getItemsByCatalogId(self, ):
1213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1214 
    if mtype == TMessageType.EXCEPTION:
1215 
      x = TApplicationException()
1216 
      x.read(self._iprot)
1217 
      self._iprot.readMessageEnd()
1218 
      raise x
1219 
    result = getItemsByCatalogId_result()
1220 
    result.read(self._iprot)
1221 
    self._iprot.readMessageEnd()
1222 
    if result.success is not None:
1223 
      return result.success
1224 
    if result.cex is not None:
1225 
      raise result.cex
1226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1227 
 
1228 
  def getValidItemsByCatalogId(self, catalog_item_id):
1229 
    """
1230 
    Parameters:
1231 
     - catalog_item_id
1232 
    """
1233 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1234 
    return self.recv_getValidItemsByCatalogId()
1235 
 
1236 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1237 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1238 
    args = getValidItemsByCatalogId_args()
1239 
    args.catalog_item_id = catalog_item_id
1240 
    args.write(self._oprot)
1241 
    self._oprot.writeMessageEnd()
1242 
    self._oprot.trans.flush()
1243 
 
1244 
  def recv_getValidItemsByCatalogId(self, ):
1245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1246 
    if mtype == TMessageType.EXCEPTION:
1247 
      x = TApplicationException()
1248 
      x.read(self._iprot)
1249 
      self._iprot.readMessageEnd()
1250 
      raise x
1251 
    result = getValidItemsByCatalogId_result()
1252 
    result.read(self._iprot)
1253 
    self._iprot.readMessageEnd()
1254 
    if result.success is not None:
1255 
      return result.success
1256 
    if result.cex is not None:
1257 
      raise result.cex
1258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1259 
 
1260 
  def getAllItems(self, isActive):
1261 
    """
1262 
    Parameters:
1263 
     - isActive
1264 
    """
1265 
    self.send_getAllItems(isActive)
1266 
    return self.recv_getAllItems()
1267 
 
1268 
  def send_getAllItems(self, isActive):
1269 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1270 
    args = getAllItems_args()
1271 
    args.isActive = isActive
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_getAllItems(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = getAllItems_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
1286 
    if result.success is not None:
1287 
      return result.success
1288 
    if result.cex is not None:
1289 
      raise result.cex
1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1291 
 
1292 
  def getAllItemsByStatus(self, itemStatus):
1293 
    """
1294 
    Parameters:
1295 
     - itemStatus
1296 
    """
1297 
    self.send_getAllItemsByStatus(itemStatus)
1298 
    return self.recv_getAllItemsByStatus()
1299 
 
1300 
  def send_getAllItemsByStatus(self, itemStatus):
1301 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1302 
    args = getAllItemsByStatus_args()
1303 
    args.itemStatus = itemStatus
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getAllItemsByStatus(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getAllItemsByStatus_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.success is not None:
1319 
      return result.success
1320 
    if result.cex is not None:
1321 
      raise result.cex
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1323 
 
1324 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1325 
    """
1326 
    Parameters:
1327 
     - entityId
1328 
     - category
1329 
     - brand
1330 
     - modelName
1331 
     - modelNumber
1332 
    """
1333 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1334 
    return self.recv_markItemAsContentComplete()
1335 
 
1336 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1337 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1338 
    args = markItemAsContentComplete_args()
1339 
    args.entityId = entityId
1340 
    args.category = category
1341 
    args.brand = brand
1342 
    args.modelName = modelName
1343 
    args.modelNumber = modelNumber
1344 
    args.write(self._oprot)
1345 
    self._oprot.writeMessageEnd()
1346 
    self._oprot.trans.flush()
1347 
 
1348 
  def recv_markItemAsContentComplete(self, ):
1349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1350 
    if mtype == TMessageType.EXCEPTION:
1351 
      x = TApplicationException()
1352 
      x.read(self._iprot)
1353 
      self._iprot.readMessageEnd()
1354 
      raise x
1355 
    result = markItemAsContentComplete_result()
1356 
    result.read(self._iprot)
1357 
    self._iprot.readMessageEnd()
1358 
    if result.success is not None:
1359 
      return result.success
1360 
    if result.cex is not None:
1361 
      raise result.cex
1362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1363 
 
1364 
  def getAllItemsInRange(self, offset, limit):
1365 
    """
1366 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1367 
 
1368 
    Parameters:
1369 
     - offset
1370 
     - limit
1371 
    """
1372 
    self.send_getAllItemsInRange(offset, limit)
1373 
    return self.recv_getAllItemsInRange()
1374 
 
1375 
  def send_getAllItemsInRange(self, offset, limit):
1376 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1377 
    args = getAllItemsInRange_args()
1378 
    args.offset = offset
1379 
    args.limit = limit
1380 
    args.write(self._oprot)
1381 
    self._oprot.writeMessageEnd()
1382 
    self._oprot.trans.flush()
1383 
 
1384 
  def recv_getAllItemsInRange(self, ):
1385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1386 
    if mtype == TMessageType.EXCEPTION:
1387 
      x = TApplicationException()
1388 
      x.read(self._iprot)
1389 
      self._iprot.readMessageEnd()
1390 
      raise x
1391 
    result = getAllItemsInRange_result()
1392 
    result.read(self._iprot)
1393 
    self._iprot.readMessageEnd()
1394 
    if result.success is not None:
1395 
      return result.success
1396 
    if result.cex is not None:
1397 
      raise result.cex
1398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1399 
 
1400 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1401 
    """
1402 
    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.
1403 
 
1404 
    Parameters:
1405 
     - itemStatus
1406 
     - offset
1407 
     - limit
1408 
    """
1409 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1410 
    return self.recv_getAllItemsByStatusInRange()
1411 
 
1412 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1413 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1414 
    args = getAllItemsByStatusInRange_args()
1415 
    args.itemStatus = itemStatus
1416 
    args.offset = offset
1417 
    args.limit = limit
1418 
    args.write(self._oprot)
1419 
    self._oprot.writeMessageEnd()
1420 
    self._oprot.trans.flush()
1421 
 
1422 
  def recv_getAllItemsByStatusInRange(self, ):
1423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1424 
    if mtype == TMessageType.EXCEPTION:
1425 
      x = TApplicationException()
1426 
      x.read(self._iprot)
1427 
      self._iprot.readMessageEnd()
1428 
      raise x
1429 
    result = getAllItemsByStatusInRange_result()
1430 
    result.read(self._iprot)
1431 
    self._iprot.readMessageEnd()
1432 
    if result.success is not None:
1433 
      return result.success
1434 
    if result.cex is not None:
1435 
      raise result.cex
1436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1437 
 
1438 
  def getItemCountByStatus(self, useStatus, itemStatus):
1439 
    """
1440 
    Gets a count of all items by status
1441 
 
1442 
    Parameters:
1443 
     - useStatus
1444 
     - itemStatus
1445 
    """
1446 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1447 
    return self.recv_getItemCountByStatus()
1448 
 
1449 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1450 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1451 
    args = getItemCountByStatus_args()
1452 
    args.useStatus = useStatus
1453 
    args.itemStatus = itemStatus
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_getItemCountByStatus(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = getItemCountByStatus_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
1468 
    if result.success is not None:
1469 
      return result.success
1470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1471 
 
1472 
  def getBestSellers(self, ):
1473 
    self.send_getBestSellers()
1474 
    return self.recv_getBestSellers()
1475 
 
1476 
  def send_getBestSellers(self, ):
1477 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1478 
    args = getBestSellers_args()
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getBestSellers(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getBestSellers_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
1493 
    if result.success is not None:
1494 
      return result.success
1495 
    if result.isex is not None:
1496 
      raise result.isex
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1498 
 
1499 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1500 
    """
1501 
    Parameters:
1502 
     - beginIndex
1503 
     - totalItems
1504 
     - brand
1505 
     - category
1506 
    """
1507 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1508 
    return self.recv_getBestSellersCatalogIds()
1509 
 
1510 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1511 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1512 
    args = getBestSellersCatalogIds_args()
1513 
    args.beginIndex = beginIndex
1514 
    args.totalItems = totalItems
1515 
    args.brand = brand
1516 
    args.category = category
1517 
    args.write(self._oprot)
1518 
    self._oprot.writeMessageEnd()
1519 
    self._oprot.trans.flush()
1520 
 
1521 
  def recv_getBestSellersCatalogIds(self, ):
1522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1523 
    if mtype == TMessageType.EXCEPTION:
1524 
      x = TApplicationException()
1525 
      x.read(self._iprot)
1526 
      self._iprot.readMessageEnd()
1527 
      raise x
1528 
    result = getBestSellersCatalogIds_result()
1529 
    result.read(self._iprot)
1530 
    self._iprot.readMessageEnd()
1531 
    if result.success is not None:
1532 
      return result.success
1533 
    if result.cex is not None:
1534 
      raise result.cex
1535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1536 
 
1537 
  def getBestSellersCount(self, ):
1538 
    self.send_getBestSellersCount()
1539 
    return self.recv_getBestSellersCount()
1540 
 
1541 
  def send_getBestSellersCount(self, ):
1542 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1543 
    args = getBestSellersCount_args()
1544 
    args.write(self._oprot)
1545 
    self._oprot.writeMessageEnd()
1546 
    self._oprot.trans.flush()
1547 
 
1548 
  def recv_getBestSellersCount(self, ):
1549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1550 
    if mtype == TMessageType.EXCEPTION:
1551 
      x = TApplicationException()
1552 
      x.read(self._iprot)
1553 
      self._iprot.readMessageEnd()
1554 
      raise x
1555 
    result = getBestSellersCount_result()
1556 
    result.read(self._iprot)
1557 
    self._iprot.readMessageEnd()
1558 
    if result.success is not None:
1559 
      return result.success
1560 
    if result.cex is not None:
1561 
      raise result.cex
1562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1563 
 
1564 
  def getBestDeals(self, ):
1565 
    self.send_getBestDeals()
1566 
    return self.recv_getBestDeals()
1567 
 
1568 
  def send_getBestDeals(self, ):
1569 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1570 
    args = getBestDeals_args()
1571 
    args.write(self._oprot)
1572 
    self._oprot.writeMessageEnd()
1573 
    self._oprot.trans.flush()
1574 
 
1575 
  def recv_getBestDeals(self, ):
1576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1577 
    if mtype == TMessageType.EXCEPTION:
1578 
      x = TApplicationException()
1579 
      x.read(self._iprot)
1580 
      self._iprot.readMessageEnd()
1581 
      raise x
1582 
    result = getBestDeals_result()
1583 
    result.read(self._iprot)
1584 
    self._iprot.readMessageEnd()
1585 
    if result.success is not None:
1586 
      return result.success
1587 
    if result.isex is not None:
1588 
      raise result.isex
1589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1590 
 
1591 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1592 
    """
1593 
    Parameters:
1594 
     - beginIndex
1595 
     - totalItems
1596 
     - brand
1597 
     - category
1598 
    """
1599 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1600 
    return self.recv_getBestDealsCatalogIds()
1601 
 
1602 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1603 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1604 
    args = getBestDealsCatalogIds_args()
1605 
    args.beginIndex = beginIndex
1606 
    args.totalItems = totalItems
1607 
    args.brand = brand
1608 
    args.category = category
1609 
    args.write(self._oprot)
1610 
    self._oprot.writeMessageEnd()
1611 
    self._oprot.trans.flush()
1612 
 
1613 
  def recv_getBestDealsCatalogIds(self, ):
1614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1615 
    if mtype == TMessageType.EXCEPTION:
1616 
      x = TApplicationException()
1617 
      x.read(self._iprot)
1618 
      self._iprot.readMessageEnd()
1619 
      raise x
1620 
    result = getBestDealsCatalogIds_result()
1621 
    result.read(self._iprot)
1622 
    self._iprot.readMessageEnd()
1623 
    if result.success is not None:
1624 
      return result.success
1625 
    if result.cex is not None:
1626 
      raise result.cex
1627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1628 
 
1629 
  def getBestDealsCount(self, ):
1630 
    self.send_getBestDealsCount()
1631 
    return self.recv_getBestDealsCount()
1632 
 
1633 
  def send_getBestDealsCount(self, ):
1634 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1635 
    args = getBestDealsCount_args()
1636 
    args.write(self._oprot)
1637 
    self._oprot.writeMessageEnd()
1638 
    self._oprot.trans.flush()
1639 
 
1640 
  def recv_getBestDealsCount(self, ):
1641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1642 
    if mtype == TMessageType.EXCEPTION:
1643 
      x = TApplicationException()
1644 
      x.read(self._iprot)
1645 
      self._iprot.readMessageEnd()
1646 
      raise x
1647 
    result = getBestDealsCount_result()
1648 
    result.read(self._iprot)
1649 
    self._iprot.readMessageEnd()
1650 
    if result.success is not None:
1651 
      return result.success
1652 
    if result.cex is not None:
1653 
      raise result.cex
1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1655 
 
1656 
  def getComingSoon(self, ):
1657 
    self.send_getComingSoon()
1658 
    return self.recv_getComingSoon()
1659 
 
1660 
  def send_getComingSoon(self, ):
1661 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1662 
    args = getComingSoon_args()
1663 
    args.write(self._oprot)
1664 
    self._oprot.writeMessageEnd()
1665 
    self._oprot.trans.flush()
1666 
 
1667 
  def recv_getComingSoon(self, ):
1668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1669 
    if mtype == TMessageType.EXCEPTION:
1670 
      x = TApplicationException()
1671 
      x.read(self._iprot)
1672 
      self._iprot.readMessageEnd()
1673 
      raise x
1674 
    result = getComingSoon_result()
1675 
    result.read(self._iprot)
1676 
    self._iprot.readMessageEnd()
1677 
    if result.success is not None:
1678 
      return result.success
1679 
    if result.isex is not None:
1680 
      raise result.isex
1681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1682 
 
1683 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1684 
    """
1685 
    Parameters:
1686 
     - beginIndex
1687 
     - totalItems
1688 
     - brand
1689 
     - category
1690 
    """
1691 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1692 
    return self.recv_getComingSoonCatalogIds()
1693 
 
1694 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1695 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1696 
    args = getComingSoonCatalogIds_args()
1697 
    args.beginIndex = beginIndex
1698 
    args.totalItems = totalItems
1699 
    args.brand = brand
1700 
    args.category = category
1701 
    args.write(self._oprot)
1702 
    self._oprot.writeMessageEnd()
1703 
    self._oprot.trans.flush()
1704 
 
1705 
  def recv_getComingSoonCatalogIds(self, ):
1706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1707 
    if mtype == TMessageType.EXCEPTION:
1708 
      x = TApplicationException()
1709 
      x.read(self._iprot)
1710 
      self._iprot.readMessageEnd()
1711 
      raise x
1712 
    result = getComingSoonCatalogIds_result()
1713 
    result.read(self._iprot)
1714 
    self._iprot.readMessageEnd()
1715 
    if result.success is not None:
1716 
      return result.success
1717 
    if result.cex is not None:
1718 
      raise result.cex
1719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1720 
 
1721 
  def getComingSoonCount(self, ):
1722 
    self.send_getComingSoonCount()
1723 
    return self.recv_getComingSoonCount()
1724 
 
1725 
  def send_getComingSoonCount(self, ):
1726 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1727 
    args = getComingSoonCount_args()
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getComingSoonCount(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getComingSoonCount_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
1742 
    if result.success is not None:
1743 
      return result.success
1744 
    if result.cex is not None:
1745 
      raise result.cex
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1747 
 
1748 
  def getLatestArrivals(self, ):
1749 
    """
1750 
    Returns a list of items sorted in the descending order by start date.
1751 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1752 
    """
1753 
    self.send_getLatestArrivals()
1754 
    return self.recv_getLatestArrivals()
1755 
 
1756 
  def send_getLatestArrivals(self, ):
1757 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1758 
    args = getLatestArrivals_args()
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getLatestArrivals(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getLatestArrivals_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success is not None:
1774 
      return result.success
1775 
    if result.isex is not None:
1776 
      raise result.isex
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1778 
 
1779 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1780 
    """
1781 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1782 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1783 
 
1784 
    Parameters:
1785 
     - beginIndex
1786 
     - totalItems
1787 
     - brand
1788 
     - categories
1789 
    """
1790 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1791 
    return self.recv_getLatestArrivalsCatalogIds()
1792 
 
1793 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1794 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1795 
    args = getLatestArrivalsCatalogIds_args()
1796 
    args.beginIndex = beginIndex
1797 
    args.totalItems = totalItems
1798 
    args.brand = brand
1799 
    args.categories = categories
1800 
    args.write(self._oprot)
1801 
    self._oprot.writeMessageEnd()
1802 
    self._oprot.trans.flush()
1803 
 
1804 
  def recv_getLatestArrivalsCatalogIds(self, ):
1805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1806 
    if mtype == TMessageType.EXCEPTION:
1807 
      x = TApplicationException()
1808 
      x.read(self._iprot)
1809 
      self._iprot.readMessageEnd()
1810 
      raise x
1811 
    result = getLatestArrivalsCatalogIds_result()
1812 
    result.read(self._iprot)
1813 
    self._iprot.readMessageEnd()
1814 
    if result.success is not None:
1815 
      return result.success
1816 
    if result.cex is not None:
1817 
      raise result.cex
1818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1819 
 
1820 
  def getLatestArrivalsCount(self, ):
1821 
    """
1822 
    Get the total number of latest arrivals we are willing to show.
1823 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1824 
    """
1825 
    self.send_getLatestArrivalsCount()
1826 
    return self.recv_getLatestArrivalsCount()
1827 
 
1828 
  def send_getLatestArrivalsCount(self, ):
1829 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1830 
    args = getLatestArrivalsCount_args()
1831 
    args.write(self._oprot)
1832 
    self._oprot.writeMessageEnd()
1833 
    self._oprot.trans.flush()
1834 
 
1835 
  def recv_getLatestArrivalsCount(self, ):
1836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1837 
    if mtype == TMessageType.EXCEPTION:
1838 
      x = TApplicationException()
1839 
      x.read(self._iprot)
1840 
      self._iprot.readMessageEnd()
1841 
      raise x
1842 
    result = getLatestArrivalsCount_result()
1843 
    result.read(self._iprot)
1844 
    self._iprot.readMessageEnd()
1845 
    if result.success is not None:
1846 
      return result.success
1847 
    if result.cex is not None:
1848 
      raise result.cex
1849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1850 
 
1851 
  def generateNewEntityID(self, ):
1852 
    self.send_generateNewEntityID()
1853 
    return self.recv_generateNewEntityID()
1854 
 
1855 
  def send_generateNewEntityID(self, ):
1856 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1857 
    args = generateNewEntityID_args()
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_generateNewEntityID(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = generateNewEntityID_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    if result.success is not None:
1873 
      return result.success
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1875 
 
1876 
  def addCategory(self, category):
1877 
    """
1878 
    All category related functions
1879 
 
1880 
    Parameters:
1881 
     - category
1882 
    """
1883 
    self.send_addCategory(category)
1884 
    return self.recv_addCategory()
1885 
 
1886 
  def send_addCategory(self, category):
1887 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1888 
    args = addCategory_args()
1889 
    args.category = category
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_addCategory(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = addCategory_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success is not None:
1905 
      return result.success
1906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1907 
 
1908 
  def getCategory(self, id):
1909 
    """
1910 
    Parameters:
1911 
     - id
1912 
    """
1913 
    self.send_getCategory(id)
1914 
    return self.recv_getCategory()
1915 
 
1916 
  def send_getCategory(self, id):
1917 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1918 
    args = getCategory_args()
1919 
    args.id = id
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_getCategory(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = getCategory_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
1934 
    if result.success is not None:
1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1937 
 
1938 
  def getAllCategories(self, ):
1939 
    self.send_getAllCategories()
1940 
    return self.recv_getAllCategories()
1941 
 
1942 
  def send_getAllCategories(self, ):
1943 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1944 
    args = getAllCategories_args()
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getAllCategories(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getAllCategories_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
1959 
    if result.success is not None:
1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1962 
 
1963 
  def getAllSimilarItems(self, itemId):
1964 
    """
1965 
    Returns the list of similar items.
1966 
 
1967 
    Parameters:
1968 
     - itemId
1969 
    """
1970 
    self.send_getAllSimilarItems(itemId)
1971 
    return self.recv_getAllSimilarItems()
1972 
 
1973 
  def send_getAllSimilarItems(self, itemId):
1974 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1975 
    args = getAllSimilarItems_args()
1976 
    args.itemId = itemId
1977 
    args.write(self._oprot)
1978 
    self._oprot.writeMessageEnd()
1979 
    self._oprot.trans.flush()
1980 
 
1981 
  def recv_getAllSimilarItems(self, ):
1982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1983 
    if mtype == TMessageType.EXCEPTION:
1984 
      x = TApplicationException()
1985 
      x.read(self._iprot)
1986 
      self._iprot.readMessageEnd()
1987 
      raise x
1988 
    result = getAllSimilarItems_result()
1989 
    result.read(self._iprot)
1990 
    self._iprot.readMessageEnd()
1991 
    if result.success is not None:
1992 
      return result.success
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1994 
 
1995 
  def addSimilarItem(self, itemId, catalogItemId):
1996 
    """
1997 
    Adds similar item.
1998 
 
1999 
    Parameters:
2000 
     - itemId
2001 
     - catalogItemId
2002 
    """
2003 
    self.send_addSimilarItem(itemId, catalogItemId)
2004 
    return self.recv_addSimilarItem()
2005 
 
2006 
  def send_addSimilarItem(self, itemId, catalogItemId):
2007 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2008 
    args = addSimilarItem_args()
2009 
    args.itemId = itemId
2010 
    args.catalogItemId = catalogItemId
2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
2015 
  def recv_addSimilarItem(self, ):
2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
2022 
    result = addSimilarItem_result()
2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
2025 
    if result.success is not None:
2026 
      return result.success
2027 
    if result.cex is not None:
2028 
      raise result.cex
2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2030 
 
6512 kshitij.so 2031 
  def addTag(self, displayName, itemId):
2032 
    """
2033 
    Tag Related
2034 
 
2035 
    Parameters:
2036 
     - displayName
2037 
     - itemId
2038 
    """
2039 
    self.send_addTag(displayName, itemId)
2040 
    return self.recv_addTag()
2041 
 
2042 
  def send_addTag(self, displayName, itemId):
2043 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2044 
    args = addTag_args()
2045 
    args.displayName = displayName
2046 
    args.itemId = itemId
2047 
    args.write(self._oprot)
2048 
    self._oprot.writeMessageEnd()
2049 
    self._oprot.trans.flush()
2050 
 
2051 
  def recv_addTag(self, ):
2052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2053 
    if mtype == TMessageType.EXCEPTION:
2054 
      x = TApplicationException()
2055 
      x.read(self._iprot)
2056 
      self._iprot.readMessageEnd()
2057 
      raise x
2058 
    result = addTag_result()
2059 
    result.read(self._iprot)
2060 
    self._iprot.readMessageEnd()
2061 
    if result.success is not None:
2062 
      return result.success
2063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2064 
 
2065 
  def deleteEntityTag(self, displayName, itemId):
2066 
    """
2067 
    Parameters:
2068 
     - displayName
2069 
     - itemId
2070 
    """
2071 
    self.send_deleteEntityTag(displayName, itemId)
2072 
    return self.recv_deleteEntityTag()
2073 
 
2074 
  def send_deleteEntityTag(self, displayName, itemId):
2075 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2076 
    args = deleteEntityTag_args()
2077 
    args.displayName = displayName
2078 
    args.itemId = itemId
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_deleteEntityTag(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = deleteEntityTag_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
2093 
    if result.success is not None:
2094 
      return result.success
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2096 
 
2097 
  def deleteTag(self, displayName):
2098 
    """
2099 
    Parameters:
2100 
     - displayName
2101 
    """
2102 
    self.send_deleteTag(displayName)
2103 
    return self.recv_deleteTag()
2104 
 
2105 
  def send_deleteTag(self, displayName):
2106 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2107 
    args = deleteTag_args()
2108 
    args.displayName = displayName
2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
2113 
  def recv_deleteTag(self, ):
2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
2120 
    result = deleteTag_result()
2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
2123 
    if result.success is not None:
2124 
      return result.success
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2126 
 
2127 
  def getAllTags(self, ):
2128 
    self.send_getAllTags()
2129 
    return self.recv_getAllTags()
2130 
 
2131 
  def send_getAllTags(self, ):
2132 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2133 
    args = getAllTags_args()
2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
2138 
  def recv_getAllTags(self, ):
2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
2145 
    result = getAllTags_result()
2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
2148 
    if result.success is not None:
2149 
      return result.success
2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2151 
 
2152 
  def getAllEntitiesByTagName(self, displayName):
2153 
    """
2154 
    Parameters:
2155 
     - displayName
2156 
    """
2157 
    self.send_getAllEntitiesByTagName(displayName)
2158 
    return self.recv_getAllEntitiesByTagName()
2159 
 
2160 
  def send_getAllEntitiesByTagName(self, displayName):
2161 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2162 
    args = getAllEntitiesByTagName_args()
2163 
    args.displayName = displayName
2164 
    args.write(self._oprot)
2165 
    self._oprot.writeMessageEnd()
2166 
    self._oprot.trans.flush()
2167 
 
2168 
  def recv_getAllEntitiesByTagName(self, ):
2169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2170 
    if mtype == TMessageType.EXCEPTION:
2171 
      x = TApplicationException()
2172 
      x.read(self._iprot)
2173 
      self._iprot.readMessageEnd()
2174 
      raise x
2175 
    result = getAllEntitiesByTagName_result()
2176 
    result.read(self._iprot)
2177 
    self._iprot.readMessageEnd()
2178 
    if result.success is not None:
2179 
      return result.success
2180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2181 
 
6845 amit.gupta 2182 
  def getAllEntityTags(self, ):
2183 
    self.send_getAllEntityTags()
2184 
    return self.recv_getAllEntityTags()
2185 
 
2186 
  def send_getAllEntityTags(self, ):
2187 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2188 
    args = getAllEntityTags_args()
2189 
    args.write(self._oprot)
2190 
    self._oprot.writeMessageEnd()
2191 
    self._oprot.trans.flush()
2192 
 
2193 
  def recv_getAllEntityTags(self, ):
2194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2195 
    if mtype == TMessageType.EXCEPTION:
2196 
      x = TApplicationException()
2197 
      x.read(self._iprot)
2198 
      self._iprot.readMessageEnd()
2199 
      raise x
2200 
    result = getAllEntityTags_result()
2201 
    result.read(self._iprot)
2202 
    self._iprot.readMessageEnd()
2203 
    if result.success is not None:
2204 
      return result.success
2205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2206 
 
8590 kshitij.so 2207 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2208 
    """
8579 kshitij.so 2209 
    Banner Related
2210 
 
6850 kshitij.so 2211 
    Parameters:
8590 kshitij.so 2212 
     - bannerCongregate
6850 kshitij.so 2213 
    """
8590 kshitij.so 2214 
    self.send_addBanner(bannerCongregate)
2215 
    self.recv_addBanner()
6850 kshitij.so 2216 
 
8590 kshitij.so 2217 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2218 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2219 
    args = addBanner_args()
8590 kshitij.so 2220 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
2225 
  def recv_addBanner(self, ):
2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
2232 
    result = addBanner_result()
2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
8590 kshitij.so 2235 
    return
6850 kshitij.so 2236 
 
8579 kshitij.so 2237 
  def updateBanner(self, banner):
2238 
    """
2239 
    Parameters:
2240 
     - banner
2241 
    """
2242 
    self.send_updateBanner(banner)
2243 
    return self.recv_updateBanner()
2244 
 
2245 
  def send_updateBanner(self, banner):
2246 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2247 
    args = updateBanner_args()
2248 
    args.banner = banner
2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
2253 
  def recv_updateBanner(self, ):
2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
2260 
    result = updateBanner_result()
2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
2263 
    if result.success is not None:
2264 
      return result.success
2265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2266 
 
6850 kshitij.so 2267 
  def getAllBanners(self, ):
2268 
    self.send_getAllBanners()
2269 
    return self.recv_getAllBanners()
2270 
 
2271 
  def send_getAllBanners(self, ):
2272 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2273 
    args = getAllBanners_args()
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_getAllBanners(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = getAllBanners_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
2288 
    if result.success is not None:
2289 
      return result.success
2290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2291 
 
2292 
  def deleteBanner(self, bannerName):
2293 
    """
2294 
    Parameters:
2295 
     - bannerName
2296 
    """
2297 
    self.send_deleteBanner(bannerName)
2298 
    return self.recv_deleteBanner()
2299 
 
2300 
  def send_deleteBanner(self, bannerName):
2301 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2302 
    args = deleteBanner_args()
2303 
    args.bannerName = bannerName
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_deleteBanner(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = deleteBanner_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    if result.success is not None:
2319 
      return result.success
2320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2321 
 
2322 
  def getBannerDetails(self, bannerName):
2323 
    """
2324 
    Parameters:
2325 
     - bannerName
2326 
    """
2327 
    self.send_getBannerDetails(bannerName)
2328 
    return self.recv_getBannerDetails()
2329 
 
2330 
  def send_getBannerDetails(self, bannerName):
2331 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2332 
    args = getBannerDetails_args()
2333 
    args.bannerName = bannerName
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_getBannerDetails(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = getBannerDetails_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    if result.success is not None:
2349 
      return result.success
2350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2351 
 
2352 
  def getActiveBanners(self, ):
2353 
    self.send_getActiveBanners()
2354 
    return self.recv_getActiveBanners()
2355 
 
2356 
  def send_getActiveBanners(self, ):
2357 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2358 
    args = getActiveBanners_args()
2359 
    args.write(self._oprot)
2360 
    self._oprot.writeMessageEnd()
2361 
    self._oprot.trans.flush()
2362 
 
2363 
  def recv_getActiveBanners(self, ):
2364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2365 
    if mtype == TMessageType.EXCEPTION:
2366 
      x = TApplicationException()
2367 
      x.read(self._iprot)
2368 
      self._iprot.readMessageEnd()
2369 
      raise x
2370 
    result = getActiveBanners_result()
2371 
    result.read(self._iprot)
2372 
    self._iprot.readMessageEnd()
2373 
    if result.success is not None:
2374 
      return result.success
2375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2376 
 
8579 kshitij.so 2377 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2378 
    """
2379 
    Parameters:
8579 kshitij.so 2380 
     - bannerMaps
6849 kshitij.so 2381 
    """
8579 kshitij.so 2382 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2383 
    return self.recv_addBannerMap()
2384 
 
8579 kshitij.so 2385 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2386 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2387 
    args = addBannerMap_args()
8579 kshitij.so 2388 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2389 
    args.write(self._oprot)
2390 
    self._oprot.writeMessageEnd()
2391 
    self._oprot.trans.flush()
2392 
 
2393 
  def recv_addBannerMap(self, ):
2394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2395 
    if mtype == TMessageType.EXCEPTION:
2396 
      x = TApplicationException()
2397 
      x.read(self._iprot)
2398 
      self._iprot.readMessageEnd()
2399 
      raise x
2400 
    result = addBannerMap_result()
2401 
    result.read(self._iprot)
2402 
    self._iprot.readMessageEnd()
2403 
    if result.success is not None:
2404 
      return result.success
2405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2406 
 
8579 kshitij.so 2407 
  def updateBannerMap(self, bannerMap):
2408 
    """
2409 
    Parameters:
2410 
     - bannerMap
2411 
    """
2412 
    self.send_updateBannerMap(bannerMap)
2413 
    return self.recv_updateBannerMap()
2414 
 
2415 
  def send_updateBannerMap(self, bannerMap):
2416 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2417 
    args = updateBannerMap_args()
2418 
    args.bannerMap = bannerMap
2419 
    args.write(self._oprot)
2420 
    self._oprot.writeMessageEnd()
2421 
    self._oprot.trans.flush()
2422 
 
2423 
  def recv_updateBannerMap(self, ):
2424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2425 
    if mtype == TMessageType.EXCEPTION:
2426 
      x = TApplicationException()
2427 
      x.read(self._iprot)
2428 
      self._iprot.readMessageEnd()
2429 
      raise x
2430 
    result = updateBannerMap_result()
2431 
    result.read(self._iprot)
2432 
    self._iprot.readMessageEnd()
2433 
    if result.success is not None:
2434 
      return result.success
2435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2436 
 
6849 kshitij.so 2437 
  def deleteBannerMap(self, bannerName):
2438 
    """
2439 
    Parameters:
2440 
     - bannerName
2441 
    """
2442 
    self.send_deleteBannerMap(bannerName)
2443 
    return self.recv_deleteBannerMap()
2444 
 
2445 
  def send_deleteBannerMap(self, bannerName):
2446 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2447 
    args = deleteBannerMap_args()
2448 
    args.bannerName = bannerName
2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_deleteBannerMap(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = deleteBannerMap_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
2463 
    if result.success is not None:
2464 
      return result.success
2465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2466 
 
2467 
  def getBannerMapDetails(self, bannerName):
2468 
    """
2469 
    Parameters:
2470 
     - bannerName
2471 
    """
2472 
    self.send_getBannerMapDetails(bannerName)
2473 
    return self.recv_getBannerMapDetails()
2474 
 
2475 
  def send_getBannerMapDetails(self, bannerName):
2476 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2477 
    args = getBannerMapDetails_args()
2478 
    args.bannerName = bannerName
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_getBannerMapDetails(self, ):
2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
2490 
    result = getBannerMapDetails_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
2493 
    if result.success is not None:
2494 
      return result.success
2495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2496 
 
8579 kshitij.so 2497 
  def addBannerUri(self, bannerUriMappings):
2498 
    """
2499 
    Parameters:
2500 
     - bannerUriMappings
2501 
    """
2502 
    self.send_addBannerUri(bannerUriMappings)
2503 
    self.recv_addBannerUri()
2504 
 
2505 
  def send_addBannerUri(self, bannerUriMappings):
2506 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2507 
    args = addBannerUri_args()
2508 
    args.bannerUriMappings = bannerUriMappings
2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_addBannerUri(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = addBannerUri_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
2523 
    return
2524 
 
2525 
  def getUriMapping(self, bannerName):
2526 
    """
2527 
    Parameters:
2528 
     - bannerName
2529 
    """
2530 
    self.send_getUriMapping(bannerName)
2531 
    return self.recv_getUriMapping()
2532 
 
2533 
  def send_getUriMapping(self, bannerName):
2534 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2535 
    args = getUriMapping_args()
2536 
    args.bannerName = bannerName
2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_getUriMapping(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = getUriMapping_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
2551 
    if result.success is not None:
2552 
      return result.success
2553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2554 
 
2555 
  def addCampaign(self, campaign):
2556 
    """
2557 
    Parameters:
2558 
     - campaign
2559 
    """
2560 
    self.send_addCampaign(campaign)
2561 
    self.recv_addCampaign()
2562 
 
2563 
  def send_addCampaign(self, campaign):
2564 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2565 
    args = addCampaign_args()
2566 
    args.campaign = campaign
2567 
    args.write(self._oprot)
2568 
    self._oprot.writeMessageEnd()
2569 
    self._oprot.trans.flush()
2570 
 
2571 
  def recv_addCampaign(self, ):
2572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2573 
    if mtype == TMessageType.EXCEPTION:
2574 
      x = TApplicationException()
2575 
      x.read(self._iprot)
2576 
      self._iprot.readMessageEnd()
2577 
      raise x
2578 
    result = addCampaign_result()
2579 
    result.read(self._iprot)
2580 
    self._iprot.readMessageEnd()
2581 
    return
2582 
 
2583 
  def getCampaigns(self, campaignName):
2584 
    """
2585 
    Parameters:
2586 
     - campaignName
2587 
    """
2588 
    self.send_getCampaigns(campaignName)
2589 
    return self.recv_getCampaigns()
2590 
 
2591 
  def send_getCampaigns(self, campaignName):
2592 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2593 
    args = getCampaigns_args()
2594 
    args.campaignName = campaignName
2595 
    args.write(self._oprot)
2596 
    self._oprot.writeMessageEnd()
2597 
    self._oprot.trans.flush()
2598 
 
2599 
  def recv_getCampaigns(self, ):
2600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2601 
    if mtype == TMessageType.EXCEPTION:
2602 
      x = TApplicationException()
2603 
      x.read(self._iprot)
2604 
      self._iprot.readMessageEnd()
2605 
      raise x
2606 
    result = getCampaigns_result()
2607 
    result.read(self._iprot)
2608 
    self._iprot.readMessageEnd()
2609 
    if result.success is not None:
2610 
      return result.success
2611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2612 
 
2613 
  def deleteCampaign(self, campaignId):
2614 
    """
2615 
    Parameters:
2616 
     - campaignId
2617 
    """
2618 
    self.send_deleteCampaign(campaignId)
2619 
    self.recv_deleteCampaign()
2620 
 
2621 
  def send_deleteCampaign(self, campaignId):
2622 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2623 
    args = deleteCampaign_args()
2624 
    args.campaignId = campaignId
2625 
    args.write(self._oprot)
2626 
    self._oprot.writeMessageEnd()
2627 
    self._oprot.trans.flush()
2628 
 
2629 
  def recv_deleteCampaign(self, ):
2630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2631 
    if mtype == TMessageType.EXCEPTION:
2632 
      x = TApplicationException()
2633 
      x.read(self._iprot)
2634 
      self._iprot.readMessageEnd()
2635 
      raise x
2636 
    result = deleteCampaign_result()
2637 
    result.read(self._iprot)
2638 
    self._iprot.readMessageEnd()
2639 
    return
2640 
 
2641 
  def getAllCampaigns(self, ):
2642 
    self.send_getAllCampaigns()
2643 
    return self.recv_getAllCampaigns()
2644 
 
2645 
  def send_getAllCampaigns(self, ):
2646 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2647 
    args = getAllCampaigns_args()
2648 
    args.write(self._oprot)
2649 
    self._oprot.writeMessageEnd()
2650 
    self._oprot.trans.flush()
2651 
 
2652 
  def recv_getAllCampaigns(self, ):
2653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2654 
    if mtype == TMessageType.EXCEPTION:
2655 
      x = TApplicationException()
2656 
      x.read(self._iprot)
2657 
      self._iprot.readMessageEnd()
2658 
      raise x
2659 
    result = getAllCampaigns_result()
2660 
    result.read(self._iprot)
2661 
    self._iprot.readMessageEnd()
2662 
    if result.success is not None:
2663 
      return result.success
2664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2665 
 
5944 mandeep.dh 2666 
  def deleteSimilarItem(self, itemId, catalogItemId):
2667 
    """
2668 
    Delete similar item.
2669 
 
2670 
    Parameters:
2671 
     - itemId
2672 
     - catalogItemId
2673 
    """
2674 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2675 
    return self.recv_deleteSimilarItem()
2676 
 
2677 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2678 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2679 
    args = deleteSimilarItem_args()
2680 
    args.itemId = itemId
2681 
    args.catalogItemId = catalogItemId
2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
2686 
  def recv_deleteSimilarItem(self, ):
2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
2693 
    result = deleteSimilarItem_result()
2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
2696 
    if result.success is not None:
2697 
      return result.success
2698 
    if result.cex is not None:
2699 
      raise result.cex
2700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2701 
 
2702 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2703 
    """
2704 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2705 
    If yes, returns the itemId else returns 0
2706 
 
2707 
    Parameters:
2708 
     - brand
2709 
     - modelNumber
2710 
     - modelName
2711 
     - color
2712 
    """
2713 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2714 
    return self.recv_checkSimilarItem()
2715 
 
2716 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2717 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2718 
    args = checkSimilarItem_args()
2719 
    args.brand = brand
2720 
    args.modelNumber = modelNumber
2721 
    args.modelName = modelName
2722 
    args.color = color
2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2727 
  def recv_checkSimilarItem(self, ):
2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2734 
    result = checkSimilarItem_result()
2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.success is not None:
2738 
      return result.success
2739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2740 
 
2741 
  def validateRiskyStatus(self, itemId):
2742 
    """
2743 
    Check wether item is risky and change status if inventory is not available for risky items
2744 
 
2745 
    Parameters:
2746 
     - itemId
2747 
    """
2748 
    self.send_validateRiskyStatus(itemId)
2749 
    self.recv_validateRiskyStatus()
2750 
 
2751 
  def send_validateRiskyStatus(self, itemId):
2752 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2753 
    args = validateRiskyStatus_args()
2754 
    args.itemId = itemId
2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
2759 
  def recv_validateRiskyStatus(self, ):
2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
2766 
    result = validateRiskyStatus_result()
2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
2769 
    return
2770 
 
2771 
  def changeItemRiskyFlag(self, itemId, risky):
2772 
    """
2773 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2774 
 
2775 
    Parameters:
2776 
     - itemId
2777 
     - risky
2778 
    """
2779 
    self.send_changeItemRiskyFlag(itemId, risky)
2780 
    self.recv_changeItemRiskyFlag()
2781 
 
2782 
  def send_changeItemRiskyFlag(self, itemId, risky):
2783 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2784 
    args = changeItemRiskyFlag_args()
2785 
    args.itemId = itemId
2786 
    args.risky = risky
2787 
    args.write(self._oprot)
2788 
    self._oprot.writeMessageEnd()
2789 
    self._oprot.trans.flush()
2790 
 
2791 
  def recv_changeItemRiskyFlag(self, ):
2792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2793 
    if mtype == TMessageType.EXCEPTION:
2794 
      x = TApplicationException()
2795 
      x.read(self._iprot)
2796 
      self._iprot.readMessageEnd()
2797 
      raise x
2798 
    result = changeItemRiskyFlag_result()
2799 
    result.read(self._iprot)
2800 
    self._iprot.readMessageEnd()
2801 
    return
2802 
 
2803 
  def getItemsByRiskyFlag(self, ):
2804 
    """
2805 
    Returns list of items marked as risky.
2806 
    """
2807 
    self.send_getItemsByRiskyFlag()
2808 
    return self.recv_getItemsByRiskyFlag()
2809 
 
2810 
  def send_getItemsByRiskyFlag(self, ):
2811 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2812 
    args = getItemsByRiskyFlag_args()
2813 
    args.write(self._oprot)
2814 
    self._oprot.writeMessageEnd()
2815 
    self._oprot.trans.flush()
2816 
 
2817 
  def recv_getItemsByRiskyFlag(self, ):
2818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2819 
    if mtype == TMessageType.EXCEPTION:
2820 
      x = TApplicationException()
2821 
      x.read(self._iprot)
2822 
      self._iprot.readMessageEnd()
2823 
      raise x
2824 
    result = getItemsByRiskyFlag_result()
2825 
    result.read(self._iprot)
2826 
    self._iprot.readMessageEnd()
2827 
    if result.success is not None:
2828 
      return result.success
2829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2830 
 
2831 
  def getItemsForMasterSheet(self, category, brand):
2832 
    """
2833 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2834 
 
2835 
    Parameters:
2836 
     - category
2837 
     - brand
2838 
    """
2839 
    self.send_getItemsForMasterSheet(category, brand)
2840 
    return self.recv_getItemsForMasterSheet()
2841 
 
2842 
  def send_getItemsForMasterSheet(self, category, brand):
2843 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2844 
    args = getItemsForMasterSheet_args()
2845 
    args.category = category
2846 
    args.brand = brand
2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
2851 
  def recv_getItemsForMasterSheet(self, ):
2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
2858 
    result = getItemsForMasterSheet_result()
2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
2861 
    if result.success is not None:
2862 
      return result.success
2863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2864 
 
2865 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2866 
    """
2867 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2868 
 
2869 
    Parameters:
2870 
     - beginIndex
2871 
     - totalItems
2872 
     - itemId
2873 
    """
2874 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2875 
    return self.recv_getSimilarItemsCatalogIds()
2876 
 
2877 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2878 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2879 
    args = getSimilarItemsCatalogIds_args()
2880 
    args.beginIndex = beginIndex
2881 
    args.totalItems = totalItems
2882 
    args.itemId = itemId
2883 
    args.write(self._oprot)
2884 
    self._oprot.writeMessageEnd()
2885 
    self._oprot.trans.flush()
2886 
 
2887 
  def recv_getSimilarItemsCatalogIds(self, ):
2888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2889 
    if mtype == TMessageType.EXCEPTION:
2890 
      x = TApplicationException()
2891 
      x.read(self._iprot)
2892 
      self._iprot.readMessageEnd()
2893 
      raise x
2894 
    result = getSimilarItemsCatalogIds_result()
2895 
    result.read(self._iprot)
2896 
    self._iprot.readMessageEnd()
2897 
    if result.success is not None:
2898 
      return result.success
2899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2900 
 
2901 
  def addProductNotification(self, itemId, email):
2902 
    """
2903 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2904 
 
2905 
    Parameters:
2906 
     - itemId
2907 
     - email
2908 
    """
2909 
    self.send_addProductNotification(itemId, email)
2910 
    return self.recv_addProductNotification()
2911 
 
2912 
  def send_addProductNotification(self, itemId, email):
2913 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2914 
    args = addProductNotification_args()
2915 
    args.itemId = itemId
2916 
    args.email = email
2917 
    args.write(self._oprot)
2918 
    self._oprot.writeMessageEnd()
2919 
    self._oprot.trans.flush()
2920 
 
2921 
  def recv_addProductNotification(self, ):
2922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2923 
    if mtype == TMessageType.EXCEPTION:
2924 
      x = TApplicationException()
2925 
      x.read(self._iprot)
2926 
      self._iprot.readMessageEnd()
2927 
      raise x
2928 
    result = addProductNotification_result()
2929 
    result.read(self._iprot)
2930 
    self._iprot.readMessageEnd()
2931 
    if result.success is not None:
2932 
      return result.success
2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2934 
 
2935 
  def sendProductNotifications(self, ):
2936 
    """
2937 
    Send the product notifications to the users for items which has stock.
2938 
    """
2939 
    self.send_sendProductNotifications()
2940 
    return self.recv_sendProductNotifications()
2941 
 
2942 
  def send_sendProductNotifications(self, ):
2943 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2944 
    args = sendProductNotifications_args()
2945 
    args.write(self._oprot)
2946 
    self._oprot.writeMessageEnd()
2947 
    self._oprot.trans.flush()
2948 
 
2949 
  def recv_sendProductNotifications(self, ):
2950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2951 
    if mtype == TMessageType.EXCEPTION:
2952 
      x = TApplicationException()
2953 
      x.read(self._iprot)
2954 
      self._iprot.readMessageEnd()
2955 
      raise x
2956 
    result = sendProductNotifications_result()
2957 
    result.read(self._iprot)
2958 
    self._iprot.readMessageEnd()
2959 
    if result.success is not None:
2960 
      return result.success
2961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2962 
 
2963 
  def getAllBrandsByCategory(self, categoryId):
2964 
    """
2965 
    Returns list of brand names for a given category Id
2966 
 
2967 
    Parameters:
2968 
     - categoryId
2969 
    """
2970 
    self.send_getAllBrandsByCategory(categoryId)
2971 
    return self.recv_getAllBrandsByCategory()
2972 
 
2973 
  def send_getAllBrandsByCategory(self, categoryId):
2974 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2975 
    args = getAllBrandsByCategory_args()
2976 
    args.categoryId = categoryId
2977 
    args.write(self._oprot)
2978 
    self._oprot.writeMessageEnd()
2979 
    self._oprot.trans.flush()
2980 
 
2981 
  def recv_getAllBrandsByCategory(self, ):
2982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2983 
    if mtype == TMessageType.EXCEPTION:
2984 
      x = TApplicationException()
2985 
      x.read(self._iprot)
2986 
      self._iprot.readMessageEnd()
2987 
      raise x
2988 
    result = getAllBrandsByCategory_result()
2989 
    result.read(self._iprot)
2990 
    self._iprot.readMessageEnd()
2991 
    if result.success is not None:
2992 
      return result.success
2993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2994 
 
2995 
  def getAllBrands(self, ):
2996 
    """
2997 
    Returns list of brand names
2998 
    """
2999 
    self.send_getAllBrands()
3000 
    return self.recv_getAllBrands()
3001 
 
3002 
  def send_getAllBrands(self, ):
3003 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3004 
    args = getAllBrands_args()
3005 
    args.write(self._oprot)
3006 
    self._oprot.writeMessageEnd()
3007 
    self._oprot.trans.flush()
3008 
 
3009 
  def recv_getAllBrands(self, ):
3010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3011 
    if mtype == TMessageType.EXCEPTION:
3012 
      x = TApplicationException()
3013 
      x.read(self._iprot)
3014 
      self._iprot.readMessageEnd()
3015 
      raise x
3016 
    result = getAllBrands_result()
3017 
    result.read(self._iprot)
3018 
    self._iprot.readMessageEnd()
3019 
    if result.success is not None:
3020 
      return result.success
3021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3022 
 
3023 
  def getAllSources(self, ):
3024 
    """
3025 
    Return list of all sources
3026 
    """
3027 
    self.send_getAllSources()
3028 
    return self.recv_getAllSources()
3029 
 
3030 
  def send_getAllSources(self, ):
3031 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3032 
    args = getAllSources_args()
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_getAllSources(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = getAllSources_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3050 
 
3051 
  def getItemPricingBySource(self, itemId, sourceId):
3052 
    """
3053 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3054 
 
3055 
    Parameters:
3056 
     - itemId
3057 
     - sourceId
3058 
    """
3059 
    self.send_getItemPricingBySource(itemId, sourceId)
3060 
    return self.recv_getItemPricingBySource()
3061 
 
3062 
  def send_getItemPricingBySource(self, itemId, sourceId):
3063 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3064 
    args = getItemPricingBySource_args()
3065 
    args.itemId = itemId
3066 
    args.sourceId = sourceId
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_getItemPricingBySource(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = getItemPricingBySource_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    if result.success is not None:
3082 
      return result.success
3083 
    if result.cex is not None:
3084 
      raise result.cex
3085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3086 
 
3087 
  def addSourceItemPricing(self, sourceItemPricing):
3088 
    """
3089 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3090 
    If item is not found or source is not found, it will throw exception.
3091 
 
3092 
    Parameters:
3093 
     - sourceItemPricing
3094 
    """
3095 
    self.send_addSourceItemPricing(sourceItemPricing)
3096 
    self.recv_addSourceItemPricing()
3097 
 
3098 
  def send_addSourceItemPricing(self, sourceItemPricing):
3099 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3100 
    args = addSourceItemPricing_args()
3101 
    args.sourceItemPricing = sourceItemPricing
3102 
    args.write(self._oprot)
3103 
    self._oprot.writeMessageEnd()
3104 
    self._oprot.trans.flush()
3105 
 
3106 
  def recv_addSourceItemPricing(self, ):
3107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3108 
    if mtype == TMessageType.EXCEPTION:
3109 
      x = TApplicationException()
3110 
      x.read(self._iprot)
3111 
      self._iprot.readMessageEnd()
3112 
      raise x
3113 
    result = addSourceItemPricing_result()
3114 
    result.read(self._iprot)
3115 
    self._iprot.readMessageEnd()
3116 
    if result.cex is not None:
3117 
      raise result.cex
3118 
    return
3119 
 
3120 
  def getAllSourcePricing(self, itemId):
3121 
    """
3122 
    Returns the list of source pricing information of an item.
3123 
    Raises an exception if item not found corresponding to itemId
3124 
 
3125 
    Parameters:
3126 
     - itemId
3127 
    """
3128 
    self.send_getAllSourcePricing(itemId)
3129 
    return self.recv_getAllSourcePricing()
3130 
 
3131 
  def send_getAllSourcePricing(self, itemId):
3132 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3133 
    args = getAllSourcePricing_args()
3134 
    args.itemId = itemId
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_getAllSourcePricing(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = getAllSourcePricing_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.success is not None:
3150 
      return result.success
3151 
    if result.cex is not None:
3152 
      raise result.cex
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3154 
 
3155 
  def getItemForSource(self, item_id, sourceId):
3156 
    """
3157 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3158 
 
3159 
    Parameters:
3160 
     - item_id
3161 
     - sourceId
3162 
    """
3163 
    self.send_getItemForSource(item_id, sourceId)
3164 
    return self.recv_getItemForSource()
3165 
 
3166 
  def send_getItemForSource(self, item_id, sourceId):
3167 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3168 
    args = getItemForSource_args()
3169 
    args.item_id = item_id
3170 
    args.sourceId = sourceId
3171 
    args.write(self._oprot)
3172 
    self._oprot.writeMessageEnd()
3173 
    self._oprot.trans.flush()
3174 
 
3175 
  def recv_getItemForSource(self, ):
3176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3177 
    if mtype == TMessageType.EXCEPTION:
3178 
      x = TApplicationException()
3179 
      x.read(self._iprot)
3180 
      self._iprot.readMessageEnd()
3181 
      raise x
3182 
    result = getItemForSource_result()
3183 
    result.read(self._iprot)
3184 
    self._iprot.readMessageEnd()
3185 
    if result.success is not None:
3186 
      return result.success
3187 
    if result.cex is not None:
3188 
      raise result.cex
3189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3190 
 
3191 
  def searchItemsInRange(self, searchTerms, offset, limit):
3192 
    """
3193 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3194 
 
3195 
    Parameters:
3196 
     - searchTerms
3197 
     - offset
3198 
     - limit
3199 
    """
3200 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3201 
    return self.recv_searchItemsInRange()
3202 
 
3203 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3204 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3205 
    args = searchItemsInRange_args()
3206 
    args.searchTerms = searchTerms
3207 
    args.offset = offset
3208 
    args.limit = limit
3209 
    args.write(self._oprot)
3210 
    self._oprot.writeMessageEnd()
3211 
    self._oprot.trans.flush()
3212 
 
3213 
  def recv_searchItemsInRange(self, ):
3214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3215 
    if mtype == TMessageType.EXCEPTION:
3216 
      x = TApplicationException()
3217 
      x.read(self._iprot)
3218 
      self._iprot.readMessageEnd()
3219 
      raise x
3220 
    result = searchItemsInRange_result()
3221 
    result.read(self._iprot)
3222 
    self._iprot.readMessageEnd()
3223 
    if result.success is not None:
3224 
      return result.success
3225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3226 
 
3227 
  def getSearchResultCount(self, searchTerms):
3228 
    """
3229 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3230 
 
3231 
    Parameters:
3232 
     - searchTerms
3233 
    """
3234 
    self.send_getSearchResultCount(searchTerms)
3235 
    return self.recv_getSearchResultCount()
3236 
 
3237 
  def send_getSearchResultCount(self, searchTerms):
3238 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3239 
    args = getSearchResultCount_args()
3240 
    args.searchTerms = searchTerms
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_getSearchResultCount(self, ):
3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3252 
    result = getSearchResultCount_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3255 
    if result.success is not None:
3256 
      return result.success
3257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3258 
 
3259 
  def getProductNotifications(self, startDateTime):
3260 
    """
3261 
    Returns a list of product notifications added after a supplied datetime
3262 
 
3263 
    Parameters:
3264 
     - startDateTime
3265 
    """
3266 
    self.send_getProductNotifications(startDateTime)
3267 
    return self.recv_getProductNotifications()
3268 
 
3269 
  def send_getProductNotifications(self, startDateTime):
3270 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3271 
    args = getProductNotifications_args()
3272 
    args.startDateTime = startDateTime
3273 
    args.write(self._oprot)
3274 
    self._oprot.writeMessageEnd()
3275 
    self._oprot.trans.flush()
3276 
 
3277 
  def recv_getProductNotifications(self, ):
3278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3279 
    if mtype == TMessageType.EXCEPTION:
3280 
      x = TApplicationException()
3281 
      x.read(self._iprot)
3282 
      self._iprot.readMessageEnd()
3283 
      raise x
3284 
    result = getProductNotifications_result()
3285 
    result.read(self._iprot)
3286 
    self._iprot.readMessageEnd()
3287 
    if result.success is not None:
3288 
      return result.success
3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3290 
 
7897 amar.kumar 3291 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3292 
    """
3293 
    Returns a list of count of requests for product notification against each item
3294 
 
3295 
    Parameters:
3296 
     - startDateTime
7897 amar.kumar 3297 
     - categoryId
5944 mandeep.dh 3298 
    """
7897 amar.kumar 3299 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3300 
    return self.recv_getProductNotificationRequestCount()
3301 
 
7897 amar.kumar 3302 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3303 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3304 
    args = getProductNotificationRequestCount_args()
3305 
    args.startDateTime = startDateTime
7897 amar.kumar 3306 
    args.categoryId = categoryId
5944 mandeep.dh 3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_getProductNotificationRequestCount(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = getProductNotificationRequestCount_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
3321 
    if result.success is not None:
3322 
      return result.success
3323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3324 
 
3325 
  def addAuthorizationLog(self, itemId, username, reason):
3326 
    """
3327 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3328 
 
3329 
    Parameters:
3330 
     - itemId
3331 
     - username
3332 
     - reason
3333 
    """
3334 
    self.send_addAuthorizationLog(itemId, username, reason)
3335 
    return self.recv_addAuthorizationLog()
3336 
 
3337 
  def send_addAuthorizationLog(self, itemId, username, reason):
3338 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3339 
    args = addAuthorizationLog_args()
3340 
    args.itemId = itemId
3341 
    args.username = username
3342 
    args.reason = reason
3343 
    args.write(self._oprot)
3344 
    self._oprot.writeMessageEnd()
3345 
    self._oprot.trans.flush()
3346 
 
3347 
  def recv_addAuthorizationLog(self, ):
3348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3349 
    if mtype == TMessageType.EXCEPTION:
3350 
      x = TApplicationException()
3351 
      x.read(self._iprot)
3352 
      self._iprot.readMessageEnd()
3353 
      raise x
3354 
    result = addAuthorizationLog_result()
3355 
    result.read(self._iprot)
3356 
    self._iprot.readMessageEnd()
3357 
    if result.success is not None:
3358 
      return result.success
3359 
    if result.cex is not None:
3360 
      raise result.cex
3361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3362 
 
3363 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3364 
    """
3365 
    Parameters:
3366 
     - catalog_item_id
3367 
     - voucherType
3368 
     - voucherAmount
3369 
    """
3370 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3371 
    return self.recv_addupdateVoucherForItem()
3372 
 
3373 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3374 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3375 
    args = addupdateVoucherForItem_args()
3376 
    args.catalog_item_id = catalog_item_id
3377 
    args.voucherType = voucherType
3378 
    args.voucherAmount = voucherAmount
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_addupdateVoucherForItem(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = addupdateVoucherForItem_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    if result.cex is not None:
3396 
      raise result.cex
3397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3398 
 
3399 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3400 
    """
3401 
    Parameters:
3402 
     - catalog_item_id
3403 
     - voucherType
3404 
    """
3405 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3406 
    return self.recv_deleteVoucherForItem()
3407 
 
3408 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3409 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3410 
    args = deleteVoucherForItem_args()
3411 
    args.catalog_item_id = catalog_item_id
3412 
    args.voucherType = voucherType
3413 
    args.write(self._oprot)
3414 
    self._oprot.writeMessageEnd()
3415 
    self._oprot.trans.flush()
3416 
 
3417 
  def recv_deleteVoucherForItem(self, ):
3418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3419 
    if mtype == TMessageType.EXCEPTION:
3420 
      x = TApplicationException()
3421 
      x.read(self._iprot)
3422 
      self._iprot.readMessageEnd()
3423 
      raise x
3424 
    result = deleteVoucherForItem_result()
3425 
    result.read(self._iprot)
3426 
    self._iprot.readMessageEnd()
3427 
    if result.success is not None:
3428 
      return result.success
3429 
    if result.cex is not None:
3430 
      raise result.cex
3431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3432 
 
3433 
  def getVoucherAmount(self, itemId, voucherType):
3434 
    """
3435 
    Parameters:
3436 
     - itemId
3437 
     - voucherType
3438 
    """
3439 
    self.send_getVoucherAmount(itemId, voucherType)
3440 
    return self.recv_getVoucherAmount()
3441 
 
3442 
  def send_getVoucherAmount(self, itemId, voucherType):
3443 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3444 
    args = getVoucherAmount_args()
3445 
    args.itemId = itemId
3446 
    args.voucherType = voucherType
3447 
    args.write(self._oprot)
3448 
    self._oprot.writeMessageEnd()
3449 
    self._oprot.trans.flush()
3450 
 
3451 
  def recv_getVoucherAmount(self, ):
3452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3453 
    if mtype == TMessageType.EXCEPTION:
3454 
      x = TApplicationException()
3455 
      x.read(self._iprot)
3456 
      self._iprot.readMessageEnd()
3457 
      raise x
3458 
    result = getVoucherAmount_result()
3459 
    result.read(self._iprot)
3460 
    self._iprot.readMessageEnd()
3461 
    if result.success is not None:
3462 
      return result.success
3463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3464 
 
3465 
  def getAllItemVouchers(self, itemId):
3466 
    """
3467 
    Parameters:
3468 
     - itemId
3469 
    """
3470 
    self.send_getAllItemVouchers(itemId)
3471 
    return self.recv_getAllItemVouchers()
3472 
 
3473 
  def send_getAllItemVouchers(self, itemId):
3474 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3475 
    args = getAllItemVouchers_args()
3476 
    args.itemId = itemId
3477 
    args.write(self._oprot)
3478 
    self._oprot.writeMessageEnd()
3479 
    self._oprot.trans.flush()
3480 
 
3481 
  def recv_getAllItemVouchers(self, ):
3482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3483 
    if mtype == TMessageType.EXCEPTION:
3484 
      x = TApplicationException()
3485 
      x.read(self._iprot)
3486 
      self._iprot.readMessageEnd()
3487 
      raise x
3488 
    result = getAllItemVouchers_result()
3489 
    result.read(self._iprot)
3490 
    self._iprot.readMessageEnd()
3491 
    if result.success is not None:
3492 
      return result.success
3493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3494 
 
3495 
  def isValidCatalogItemId(self, catalog_item_id):
3496 
    """
3497 
    Parameters:
3498 
     - catalog_item_id
3499 
    """
3500 
    self.send_isValidCatalogItemId(catalog_item_id)
3501 
    return self.recv_isValidCatalogItemId()
3502 
 
3503 
  def send_isValidCatalogItemId(self, catalog_item_id):
3504 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3505 
    args = isValidCatalogItemId_args()
3506 
    args.catalog_item_id = catalog_item_id
3507 
    args.write(self._oprot)
3508 
    self._oprot.writeMessageEnd()
3509 
    self._oprot.trans.flush()
3510 
 
3511 
  def recv_isValidCatalogItemId(self, ):
3512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3513 
    if mtype == TMessageType.EXCEPTION:
3514 
      x = TApplicationException()
3515 
      x.read(self._iprot)
3516 
      self._iprot.readMessageEnd()
3517 
      raise x
3518 
    result = isValidCatalogItemId_result()
3519 
    result.read(self._iprot)
3520 
    self._iprot.readMessageEnd()
3521 
    if result.success is not None:
3522 
      return result.success
3523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3524 
 
7330 amit.gupta 3525 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3526 
    """
3527 
    Parameters:
3528 
     - itemId
7330 amit.gupta 3529 
     - stateId
6039 amit.gupta 3530 
     - price
3531 
    """
7330 amit.gupta 3532 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3533 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3534 
 
7330 amit.gupta 3535 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3536 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3537 
    args = getVatPercentageForItem_args()
3538 
    args.itemId = itemId
7330 amit.gupta 3539 
    args.stateId = stateId
6039 amit.gupta 3540 
    args.price = price
3541 
    args.write(self._oprot)
3542 
    self._oprot.writeMessageEnd()
3543 
    self._oprot.trans.flush()
3544 
 
3545 
  def recv_getVatPercentageForItem(self, ):
3546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3547 
    if mtype == TMessageType.EXCEPTION:
3548 
      x = TApplicationException()
3549 
      x.read(self._iprot)
3550 
      self._iprot.readMessageEnd()
3551 
      raise x
3552 
    result = getVatPercentageForItem_result()
3553 
    result.read(self._iprot)
3554 
    self._iprot.readMessageEnd()
3555 
    if result.success is not None:
3556 
      return result.success
7340 amit.gupta 3557 
    if result.cex is not None:
3558 
      raise result.cex
6039 amit.gupta 3559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3560 
 
3561 
  def getVatAmountForItem(self, itemId, price):
3562 
    """
3563 
    Parameters:
3564 
     - itemId
3565 
     - price
3566 
    """
3567 
    self.send_getVatAmountForItem(itemId, price)
3568 
    return self.recv_getVatAmountForItem()
3569 
 
3570 
  def send_getVatAmountForItem(self, itemId, price):
3571 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3572 
    args = getVatAmountForItem_args()
3573 
    args.itemId = itemId
3574 
    args.price = price
3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_getVatAmountForItem(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = getVatAmountForItem_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
3589 
    if result.success is not None:
3590 
      return result.success
3591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3592 
 
6531 vikram.rag 3593 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3594 
    """
3595 
    Parameters:
3596 
     - offset
3597 
     - limit
3598 
    """
3599 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3600 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3601 
 
6531 vikram.rag 3602 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3603 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3604 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3605 
    args.offset = offset
3606 
    args.limit = limit
3607 
    args.write(self._oprot)
3608 
    self._oprot.writeMessageEnd()
3609 
    self._oprot.trans.flush()
3610 
 
3611 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3613 
    if mtype == TMessageType.EXCEPTION:
3614 
      x = TApplicationException()
3615 
      x.read(self._iprot)
3616 
      self._iprot.readMessageEnd()
3617 
      raise x
3618 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3619 
    result.read(self._iprot)
3620 
    self._iprot.readMessageEnd()
3621 
    if result.success is not None:
3622 
      return result.success
3623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3624 
 
6821 amar.kumar 3625 
  def getAllAliveItems(self, ):
3626 
    self.send_getAllAliveItems()
3627 
    return self.recv_getAllAliveItems()
3628 
 
3629 
  def send_getAllAliveItems(self, ):
3630 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3631 
    args = getAllAliveItems_args()
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_getAllAliveItems(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = getAllAliveItems_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    if result.success is not None:
3647 
      return result.success
3648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3649 
 
6921 anupam.sin 3650 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3651 
    """
3652 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3653 
 
6805 anupam.sin 3654 
    Parameters:
3655 
     - itemId
6921 anupam.sin 3656 
     - price
6805 anupam.sin 3657 
     - insurerId
3658 
     - quantity
3659 
    """
6921 anupam.sin 3660 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3661 
    return self.recv_getInsuranceAmount()
3662 
 
6921 anupam.sin 3663 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3664 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3665 
    args = getInsuranceAmount_args()
3666 
    args.itemId = itemId
6921 anupam.sin 3667 
    args.price = price
6805 anupam.sin 3668 
    args.insurerId = insurerId
3669 
    args.quantity = quantity
3670 
    args.write(self._oprot)
3671 
    self._oprot.writeMessageEnd()
3672 
    self._oprot.trans.flush()
3673 
 
3674 
  def recv_getInsuranceAmount(self, ):
3675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3676 
    if mtype == TMessageType.EXCEPTION:
3677 
      x = TApplicationException()
3678 
      x.read(self._iprot)
3679 
      self._iprot.readMessageEnd()
3680 
      raise x
3681 
    result = getInsuranceAmount_result()
3682 
    result.read(self._iprot)
3683 
    self._iprot.readMessageEnd()
3684 
    if result.success is not None:
3685 
      return result.success
3686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3687 
 
3688 
  def getInsurer(self, insurerId):
3689 
    """
3690 
    Parameters:
3691 
     - insurerId
3692 
    """
3693 
    self.send_getInsurer(insurerId)
3694 
    return self.recv_getInsurer()
3695 
 
3696 
  def send_getInsurer(self, insurerId):
3697 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3698 
    args = getInsurer_args()
3699 
    args.insurerId = insurerId
3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
3704 
  def recv_getInsurer(self, ):
3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
3711 
    result = getInsurer_result()
3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3714 
    if result.success is not None:
3715 
      return result.success
3716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3717 
 
6838 vikram.rag 3718 
  def getAllInsurers(self, ):
3719 
    self.send_getAllInsurers()
3720 
    return self.recv_getAllInsurers()
6805 anupam.sin 3721 
 
6838 vikram.rag 3722 
  def send_getAllInsurers(self, ):
3723 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3724 
    args = getAllInsurers_args()
3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_getAllInsurers(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = getAllInsurers_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
3739 
    if result.success is not None:
3740 
      return result.success
3741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3742 
 
6962 rajveer 3743 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3744 
    """
3745 
    Parameters:
3746 
     - insurerId
3747 
     - amount
3748 
    """
3749 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3750 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3751 
 
6962 rajveer 3752 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3753 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3754 
    args = updateInsuranceDeclaredAmount_args()
3755 
    args.insurerId = insurerId
3756 
    args.amount = amount
3757 
    args.write(self._oprot)
3758 
    self._oprot.writeMessageEnd()
3759 
    self._oprot.trans.flush()
3760 
 
3761 
  def recv_updateInsuranceDeclaredAmount(self, ):
3762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3763 
    if mtype == TMessageType.EXCEPTION:
3764 
      x = TApplicationException()
3765 
      x.read(self._iprot)
3766 
      self._iprot.readMessageEnd()
3767 
      raise x
3768 
    result = updateInsuranceDeclaredAmount_result()
3769 
    result.read(self._iprot)
3770 
    self._iprot.readMessageEnd()
3771 
    return
3772 
 
7190 amar.kumar 3773 
  def getFreebieForItem(self, itemId):
3774 
    """
3775 
    Parameters:
3776 
     - itemId
3777 
    """
3778 
    self.send_getFreebieForItem(itemId)
3779 
    return self.recv_getFreebieForItem()
6962 rajveer 3780 
 
7190 amar.kumar 3781 
  def send_getFreebieForItem(self, itemId):
3782 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3783 
    args = getFreebieForItem_args()
3784 
    args.itemId = itemId
3785 
    args.write(self._oprot)
3786 
    self._oprot.writeMessageEnd()
3787 
    self._oprot.trans.flush()
3788 
 
3789 
  def recv_getFreebieForItem(self, ):
3790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3791 
    if mtype == TMessageType.EXCEPTION:
3792 
      x = TApplicationException()
3793 
      x.read(self._iprot)
3794 
      self._iprot.readMessageEnd()
3795 
      raise x
3796 
    result = getFreebieForItem_result()
3797 
    result.read(self._iprot)
3798 
    self._iprot.readMessageEnd()
3799 
    if result.success is not None:
3800 
      return result.success
3801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3802 
 
3803 
  def addOrUpdateFreebieForItem(self, freebieItem):
3804 
    """
3805 
    Parameters:
3806 
     - freebieItem
3807 
    """
3808 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3809 
    self.recv_addOrUpdateFreebieForItem()
3810 
 
3811 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3812 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3813 
    args = addOrUpdateFreebieForItem_args()
3814 
    args.freebieItem = freebieItem
3815 
    args.write(self._oprot)
3816 
    self._oprot.writeMessageEnd()
3817 
    self._oprot.trans.flush()
3818 
 
3819 
  def recv_addOrUpdateFreebieForItem(self, ):
3820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3821 
    if mtype == TMessageType.EXCEPTION:
3822 
      x = TApplicationException()
3823 
      x.read(self._iprot)
3824 
      self._iprot.readMessageEnd()
3825 
      raise x
3826 
    result = addOrUpdateFreebieForItem_result()
3827 
    result.read(self._iprot)
3828 
    self._iprot.readMessageEnd()
3829 
    return
3830 
 
7272 amit.gupta 3831 
  def addOrUpdateBrandInfo(self, brandInfo):
3832 
    """
3833 
    Parameters:
3834 
     - brandInfo
3835 
    """
3836 
    self.send_addOrUpdateBrandInfo(brandInfo)
3837 
    self.recv_addOrUpdateBrandInfo()
3838 
 
3839 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3840 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3841 
    args = addOrUpdateBrandInfo_args()
3842 
    args.brandInfo = brandInfo
3843 
    args.write(self._oprot)
3844 
    self._oprot.writeMessageEnd()
3845 
    self._oprot.trans.flush()
3846 
 
3847 
  def recv_addOrUpdateBrandInfo(self, ):
3848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3849 
    if mtype == TMessageType.EXCEPTION:
3850 
      x = TApplicationException()
3851 
      x.read(self._iprot)
3852 
      self._iprot.readMessageEnd()
3853 
      raise x
3854 
    result = addOrUpdateBrandInfo_result()
3855 
    result.read(self._iprot)
3856 
    self._iprot.readMessageEnd()
3857 
    return
3858 
 
3859 
  def getBrandInfo(self, ):
3860 
    self.send_getBrandInfo()
3861 
    return self.recv_getBrandInfo()
3862 
 
3863 
  def send_getBrandInfo(self, ):
3864 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3865 
    args = getBrandInfo_args()
3866 
    args.write(self._oprot)
3867 
    self._oprot.writeMessageEnd()
3868 
    self._oprot.trans.flush()
3869 
 
3870 
  def recv_getBrandInfo(self, ):
3871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3872 
    if mtype == TMessageType.EXCEPTION:
3873 
      x = TApplicationException()
3874 
      x.read(self._iprot)
3875 
      self._iprot.readMessageEnd()
3876 
      raise x
3877 
    result = getBrandInfo_result()
3878 
    result.read(self._iprot)
3879 
    self._iprot.readMessageEnd()
3880 
    if result.success is not None:
3881 
      return result.success
3882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3883 
 
7256 rajveer 3884 
  def getStorePricing(self, itemId):
3885 
    """
3886 
    Parameters:
3887 
     - itemId
3888 
    """
3889 
    self.send_getStorePricing(itemId)
3890 
    return self.recv_getStorePricing()
7190 amar.kumar 3891 
 
7256 rajveer 3892 
  def send_getStorePricing(self, itemId):
3893 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3894 
    args = getStorePricing_args()
3895 
    args.itemId = itemId
3896 
    args.write(self._oprot)
3897 
    self._oprot.writeMessageEnd()
3898 
    self._oprot.trans.flush()
3899 
 
3900 
  def recv_getStorePricing(self, ):
3901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3902 
    if mtype == TMessageType.EXCEPTION:
3903 
      x = TApplicationException()
3904 
      x.read(self._iprot)
3905 
      self._iprot.readMessageEnd()
3906 
      raise x
3907 
    result = getStorePricing_result()
3908 
    result.read(self._iprot)
3909 
    self._iprot.readMessageEnd()
3910 
    if result.success is not None:
3911 
      return result.success
3912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3913 
 
7306 rajveer 3914 
  def getStorePricings(self, itemIds):
3915 
    """
3916 
    Parameters:
3917 
     - itemIds
3918 
    """
3919 
    self.send_getStorePricings(itemIds)
3920 
    return self.recv_getStorePricings()
3921 
 
3922 
  def send_getStorePricings(self, itemIds):
3923 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3924 
    args = getStorePricings_args()
3925 
    args.itemIds = itemIds
3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_getStorePricings(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = getStorePricings_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3940 
    if result.success is not None:
3941 
      return result.success
3942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3943 
 
7382 rajveer 3944 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3945 
    """
3946 
    Parameters:
3947 
     - sp
7382 rajveer 3948 
     - allColors
7265 rajveer 3949 
    """
7382 rajveer 3950 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3951 
    self.recv_updateStorePricing()
7256 rajveer 3952 
 
7382 rajveer 3953 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3954 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3955 
    args = updateStorePricing_args()
3956 
    args.sp = sp
7382 rajveer 3957 
    args.allColors = allColors
7265 rajveer 3958 
    args.write(self._oprot)
3959 
    self._oprot.writeMessageEnd()
3960 
    self._oprot.trans.flush()
3961 
 
3962 
  def recv_updateStorePricing(self, ):
3963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3964 
    if mtype == TMessageType.EXCEPTION:
3965 
      x = TApplicationException()
3966 
      x.read(self._iprot)
3967 
      self._iprot.readMessageEnd()
3968 
      raise x
3969 
    result = updateStorePricing_result()
3970 
    result.read(self._iprot)
3971 
    self._iprot.readMessageEnd()
3972 
    return
3973 
 
7281 kshitij.so 3974 
  def getAllAmazonListedItems(self, ):
3975 
    self.send_getAllAmazonListedItems()
3976 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3977 
 
7281 kshitij.so 3978 
  def send_getAllAmazonListedItems(self, ):
3979 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3980 
    args = getAllAmazonListedItems_args()
3981 
    args.write(self._oprot)
3982 
    self._oprot.writeMessageEnd()
3983 
    self._oprot.trans.flush()
3984 
 
3985 
  def recv_getAllAmazonListedItems(self, ):
3986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3987 
    if mtype == TMessageType.EXCEPTION:
3988 
      x = TApplicationException()
3989 
      x.read(self._iprot)
3990 
      self._iprot.readMessageEnd()
3991 
      raise x
3992 
    result = getAllAmazonListedItems_result()
3993 
    result.read(self._iprot)
3994 
    self._iprot.readMessageEnd()
3995 
    if result.success is not None:
3996 
      return result.success
3997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3998 
 
8619 kshitij.so 3999 
  def searchAmazonItems(self, searchTerm, offset, limit):
4000 
    """
4001 
    Parameters:
4002 
     - searchTerm
4003 
     - offset
4004 
     - limit
4005 
    """
4006 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4007 
    return self.recv_searchAmazonItems()
4008 
 
4009 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4010 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4011 
    args = searchAmazonItems_args()
4012 
    args.searchTerm = searchTerm
4013 
    args.offset = offset
4014 
    args.limit = limit
4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_searchAmazonItems(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = searchAmazonItems_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    if result.success is not None:
4030 
      return result.success
4031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4032 
 
4033 
  def getAmazonSearchResultCount(self, searchTerm):
4034 
    """
4035 
    Parameters:
4036 
     - searchTerm
4037 
    """
4038 
    self.send_getAmazonSearchResultCount(searchTerm)
4039 
    return self.recv_getAmazonSearchResultCount()
4040 
 
4041 
  def send_getAmazonSearchResultCount(self, searchTerm):
4042 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4043 
    args = getAmazonSearchResultCount_args()
4044 
    args.searchTerm = searchTerm
4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_getAmazonSearchResultCount(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = getAmazonSearchResultCount_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
4059 
    if result.success is not None:
4060 
      return result.success
4061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4062 
 
4063 
  def getCountForAmazonlistedItems(self, ):
4064 
    self.send_getCountForAmazonlistedItems()
4065 
    return self.recv_getCountForAmazonlistedItems()
4066 
 
4067 
  def send_getCountForAmazonlistedItems(self, ):
4068 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4069 
    args = getCountForAmazonlistedItems_args()
4070 
    args.write(self._oprot)
4071 
    self._oprot.writeMessageEnd()
4072 
    self._oprot.trans.flush()
4073 
 
4074 
  def recv_getCountForAmazonlistedItems(self, ):
4075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4076 
    if mtype == TMessageType.EXCEPTION:
4077 
      x = TApplicationException()
4078 
      x.read(self._iprot)
4079 
      self._iprot.readMessageEnd()
4080 
      raise x
4081 
    result = getCountForAmazonlistedItems_result()
4082 
    result.read(self._iprot)
4083 
    self._iprot.readMessageEnd()
4084 
    if result.success is not None:
4085 
      return result.success
4086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4087 
 
7281 kshitij.so 4088 
  def getAmazonItemDetails(self, itemId):
4089 
    """
4090 
    Parameters:
4091 
     - itemId
4092 
    """
4093 
    self.send_getAmazonItemDetails(itemId)
4094 
    return self.recv_getAmazonItemDetails()
4095 
 
4096 
  def send_getAmazonItemDetails(self, itemId):
4097 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4098 
    args = getAmazonItemDetails_args()
4099 
    args.itemId = itemId
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_getAmazonItemDetails(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = getAmazonItemDetails_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.success is not None:
4115 
      return result.success
4116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4117 
 
8168 kshitij.so 4118 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4119 
    """
4120 
    Parameters:
8168 kshitij.so 4121 
     - amazonlisted
7281 kshitij.so 4122 
    """
8168 kshitij.so 4123 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4124 
    self.recv_updateAmazonItemDetails()
4125 
 
8168 kshitij.so 4126 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4127 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4128 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4129 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_updateAmazonItemDetails(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = updateAmazonItemDetails_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
4144 
    return
4145 
 
4146 
  def addAmazonItem(self, amazonlisted):
4147 
    """
4148 
    Parameters:
4149 
     - amazonlisted
4150 
    """
4151 
    self.send_addAmazonItem(amazonlisted)
4152 
    self.recv_addAmazonItem()
4153 
 
4154 
  def send_addAmazonItem(self, amazonlisted):
4155 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4156 
    args = addAmazonItem_args()
4157 
    args.amazonlisted = amazonlisted
4158 
    args.write(self._oprot)
4159 
    self._oprot.writeMessageEnd()
4160 
    self._oprot.trans.flush()
4161 
 
4162 
  def recv_addAmazonItem(self, ):
4163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4164 
    if mtype == TMessageType.EXCEPTION:
4165 
      x = TApplicationException()
4166 
      x.read(self._iprot)
4167 
      self._iprot.readMessageEnd()
4168 
      raise x
4169 
    result = addAmazonItem_result()
4170 
    result.read(self._iprot)
4171 
    self._iprot.readMessageEnd()
4172 
    return
4173 
 
7291 vikram.rag 4174 
  def getAsinItems(self, ):
4175 
    self.send_getAsinItems()
4176 
    return self.recv_getAsinItems()
7281 kshitij.so 4177 
 
7291 vikram.rag 4178 
  def send_getAsinItems(self, ):
4179 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4180 
    args = getAsinItems_args()
4181 
    args.write(self._oprot)
4182 
    self._oprot.writeMessageEnd()
4183 
    self._oprot.trans.flush()
4184 
 
4185 
  def recv_getAsinItems(self, ):
4186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4187 
    if mtype == TMessageType.EXCEPTION:
4188 
      x = TApplicationException()
4189 
      x.read(self._iprot)
4190 
      self._iprot.readMessageEnd()
4191 
      raise x
4192 
    result = getAsinItems_result()
4193 
    result.read(self._iprot)
4194 
    self._iprot.readMessageEnd()
4195 
    if result.success is not None:
4196 
      return result.success
4197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4198 
 
4199 
  def getAllFbaListedItems(self, ):
4200 
    self.send_getAllFbaListedItems()
4201 
    return self.recv_getAllFbaListedItems()
4202 
 
4203 
  def send_getAllFbaListedItems(self, ):
4204 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4205 
    args = getAllFbaListedItems_args()
4206 
    args.write(self._oprot)
4207 
    self._oprot.writeMessageEnd()
4208 
    self._oprot.trans.flush()
4209 
 
4210 
  def recv_getAllFbaListedItems(self, ):
4211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4212 
    if mtype == TMessageType.EXCEPTION:
4213 
      x = TApplicationException()
4214 
      x.read(self._iprot)
4215 
      self._iprot.readMessageEnd()
4216 
      raise x
4217 
    result = getAllFbaListedItems_result()
4218 
    result.read(self._iprot)
4219 
    self._iprot.readMessageEnd()
4220 
    if result.success is not None:
4221 
      return result.success
4222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4223 
 
4224 
  def getAllNonFbaListedItems(self, ):
4225 
    self.send_getAllNonFbaListedItems()
4226 
    return self.recv_getAllNonFbaListedItems()
4227 
 
4228 
  def send_getAllNonFbaListedItems(self, ):
4229 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4230 
    args = getAllNonFbaListedItems_args()
4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_getAllNonFbaListedItems(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = getAllNonFbaListedItems_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.success is not None:
4246 
      return result.success
4247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4248 
 
7460 kshitij.so 4249 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4250 
    """
4251 
    Parameters:
4252 
     - itemId
4253 
     - holdInventory
4254 
     - defaultInventory
4255 
    """
4256 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4257 
    return self.recv_updateItemInventory()
7291 vikram.rag 4258 
 
7460 kshitij.so 4259 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4260 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4261 
    args = updateItemInventory_args()
4262 
    args.itemId = itemId
4263 
    args.holdInventory = holdInventory
4264 
    args.defaultInventory = defaultInventory
4265 
    args.write(self._oprot)
4266 
    self._oprot.writeMessageEnd()
4267 
    self._oprot.trans.flush()
4268 
 
4269 
  def recv_updateItemInventory(self, ):
4270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4271 
    if mtype == TMessageType.EXCEPTION:
4272 
      x = TApplicationException()
4273 
      x.read(self._iprot)
4274 
      self._iprot.readMessageEnd()
4275 
      raise x
4276 
    result = updateItemInventory_result()
4277 
    result.read(self._iprot)
4278 
    self._iprot.readMessageEnd()
4279 
    if result.success is not None:
4280 
      return result.success
4281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4282 
 
7770 kshitij.so 4283 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4284 
    """
4285 
    Parameters:
4286 
     - type
4287 
     - sku
4288 
     - timestamp
4289 
    """
4290 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4291 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4292 
 
7770 kshitij.so 4293 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4294 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4295 
    args = updateTimestampForAmazonFeeds_args()
4296 
    args.type = type
4297 
    args.sku = sku
4298 
    args.timestamp = timestamp
4299 
    args.write(self._oprot)
4300 
    self._oprot.writeMessageEnd()
4301 
    self._oprot.trans.flush()
4302 
 
4303 
  def recv_updateTimestampForAmazonFeeds(self, ):
4304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4305 
    if mtype == TMessageType.EXCEPTION:
4306 
      x = TApplicationException()
4307 
      x.read(self._iprot)
4308 
      self._iprot.readMessageEnd()
4309 
      raise x
4310 
    result = updateTimestampForAmazonFeeds_result()
4311 
    result.read(self._iprot)
4312 
    self._iprot.readMessageEnd()
4313 
    if result.success is not None:
4314 
      return result.success
4315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4316 
 
7897 amar.kumar 4317 
  def getAllParentCategories(self, ):
4318 
    self.send_getAllParentCategories()
4319 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4320 
 
7897 amar.kumar 4321 
  def send_getAllParentCategories(self, ):
4322 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4323 
    args = getAllParentCategories_args()
4324 
    args.write(self._oprot)
4325 
    self._oprot.writeMessageEnd()
4326 
    self._oprot.trans.flush()
4327 
 
4328 
  def recv_getAllParentCategories(self, ):
4329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4330 
    if mtype == TMessageType.EXCEPTION:
4331 
      x = TApplicationException()
4332 
      x.read(self._iprot)
4333 
      self._iprot.readMessageEnd()
4334 
      raise x
4335 
    result = getAllParentCategories_result()
4336 
    result.read(self._iprot)
4337 
    self._iprot.readMessageEnd()
4338 
    if result.success is not None:
4339 
      return result.success
4340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4341 
 
7977 kshitij.so 4342 
  def addPageViewEvent(self, pageViewEvents):
4343 
    """
4344 
    Parameters:
4345 
     - pageViewEvents
4346 
    """
4347 
    self.send_addPageViewEvent(pageViewEvents)
4348 
    self.recv_addPageViewEvent()
7897 amar.kumar 4349 
 
7977 kshitij.so 4350 
  def send_addPageViewEvent(self, pageViewEvents):
4351 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4352 
    args = addPageViewEvent_args()
4353 
    args.pageViewEvents = pageViewEvents
4354 
    args.write(self._oprot)
4355 
    self._oprot.writeMessageEnd()
4356 
    self._oprot.trans.flush()
4357 
 
4358 
  def recv_addPageViewEvent(self, ):
4359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4360 
    if mtype == TMessageType.EXCEPTION:
4361 
      x = TApplicationException()
4362 
      x.read(self._iprot)
4363 
      self._iprot.readMessageEnd()
4364 
      raise x
4365 
    result = addPageViewEvent_result()
4366 
    result.read(self._iprot)
4367 
    self._iprot.readMessageEnd()
4368 
    return
4369 
 
4370 
  def addCartEvent(self, cartEvents):
4371 
    """
4372 
    Parameters:
4373 
     - cartEvents
4374 
    """
4375 
    self.send_addCartEvent(cartEvents)
4376 
    self.recv_addCartEvent()
4377 
 
4378 
  def send_addCartEvent(self, cartEvents):
4379 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4380 
    args = addCartEvent_args()
4381 
    args.cartEvents = cartEvents
4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_addCartEvent(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = addCartEvent_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    return
4397 
 
8182 amar.kumar 4398 
  def addEbayItem(self, ebayItem):
4399 
    """
4400 
    Parameters:
4401 
     - ebayItem
4402 
    """
4403 
    self.send_addEbayItem(ebayItem)
4404 
    self.recv_addEbayItem()
4405 
 
4406 
  def send_addEbayItem(self, ebayItem):
4407 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4408 
    args = addEbayItem_args()
4409 
    args.ebayItem = ebayItem
4410 
    args.write(self._oprot)
4411 
    self._oprot.writeMessageEnd()
4412 
    self._oprot.trans.flush()
4413 
 
4414 
  def recv_addEbayItem(self, ):
4415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4416 
    if mtype == TMessageType.EXCEPTION:
4417 
      x = TApplicationException()
4418 
      x.read(self._iprot)
4419 
      self._iprot.readMessageEnd()
4420 
      raise x
4421 
    result = addEbayItem_result()
4422 
    result.read(self._iprot)
4423 
    self._iprot.readMessageEnd()
4424 
    return
4425 
 
4426 
  def getEbayItem(self, listingId):
4427 
    """
4428 
    Parameters:
4429 
     - listingId
4430 
    """
4431 
    self.send_getEbayItem(listingId)
4432 
    return self.recv_getEbayItem()
4433 
 
4434 
  def send_getEbayItem(self, listingId):
4435 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4436 
    args = getEbayItem_args()
4437 
    args.listingId = listingId
4438 
    args.write(self._oprot)
4439 
    self._oprot.writeMessageEnd()
4440 
    self._oprot.trans.flush()
4441 
 
4442 
  def recv_getEbayItem(self, ):
4443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4444 
    if mtype == TMessageType.EXCEPTION:
4445 
      x = TApplicationException()
4446 
      x.read(self._iprot)
4447 
      self._iprot.readMessageEnd()
4448 
      raise x
4449 
    result = getEbayItem_result()
4450 
    result.read(self._iprot)
4451 
    self._iprot.readMessageEnd()
4452 
    if result.success is not None:
4453 
      return result.success
4454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4455 
 
4456 
  def updateEbayItem(self, ebayItem):
4457 
    """
4458 
    Parameters:
4459 
     - ebayItem
4460 
    """
4461 
    self.send_updateEbayItem(ebayItem)
4462 
    self.recv_updateEbayItem()
4463 
 
4464 
  def send_updateEbayItem(self, ebayItem):
4465 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4466 
    args = updateEbayItem_args()
4467 
    args.ebayItem = ebayItem
4468 
    args.write(self._oprot)
4469 
    self._oprot.writeMessageEnd()
4470 
    self._oprot.trans.flush()
4471 
 
4472 
  def recv_updateEbayItem(self, ):
4473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4474 
    if mtype == TMessageType.EXCEPTION:
4475 
      x = TApplicationException()
4476 
      x.read(self._iprot)
4477 
      self._iprot.readMessageEnd()
4478 
      raise x
4479 
    result = updateEbayItem_result()
4480 
    result.read(self._iprot)
4481 
    self._iprot.readMessageEnd()
4482 
    return
4483 
 
8139 kshitij.so 4484 
  def getAmazonListedItems(self, offset, limit):
4485 
    """
4486 
    Parameters:
4487 
     - offset
4488 
     - limit
4489 
    """
4490 
    self.send_getAmazonListedItems(offset, limit)
4491 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4492 
 
8139 kshitij.so 4493 
  def send_getAmazonListedItems(self, offset, limit):
4494 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4495 
    args = getAmazonListedItems_args()
4496 
    args.offset = offset
4497 
    args.limit = limit
4498 
    args.write(self._oprot)
4499 
    self._oprot.writeMessageEnd()
4500 
    self._oprot.trans.flush()
4501 
 
4502 
  def recv_getAmazonListedItems(self, ):
4503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4504 
    if mtype == TMessageType.EXCEPTION:
4505 
      x = TApplicationException()
4506 
      x.read(self._iprot)
4507 
      self._iprot.readMessageEnd()
4508 
      raise x
4509 
    result = getAmazonListedItems_result()
4510 
    result.read(self._iprot)
4511 
    self._iprot.readMessageEnd()
4512 
    if result.success is not None:
4513 
      return result.success
4514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4515 
 
8168 kshitij.so 4516 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4517 
    """
4518 
    Parameters:
4519 
     - amazonlisted
4520 
    """
4521 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4522 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4523 
 
8168 kshitij.so 4524 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4525 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4526 
    args = updateAmazonAttributesInBulk_args()
4527 
    args.amazonlisted = amazonlisted
4528 
    args.write(self._oprot)
4529 
    self._oprot.writeMessageEnd()
4530 
    self._oprot.trans.flush()
4531 
 
4532 
  def recv_updateAmazonAttributesInBulk(self, ):
4533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4534 
    if mtype == TMessageType.EXCEPTION:
4535 
      x = TApplicationException()
4536 
      x.read(self._iprot)
4537 
      self._iprot.readMessageEnd()
4538 
      raise x
4539 
    result = updateAmazonAttributesInBulk_result()
4540 
    result.read(self._iprot)
4541 
    self._iprot.readMessageEnd()
4542 
    if result.success is not None:
4543 
      return result.success
4544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4545 
 
8379 vikram.rag 4546 
  def getAllItemstoListOnFba(self, ):
4547 
    self.send_getAllItemstoListOnFba()
4548 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4549 
 
8379 vikram.rag 4550 
  def send_getAllItemstoListOnFba(self, ):
4551 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4552 
    args = getAllItemstoListOnFba_args()
4553 
    args.write(self._oprot)
4554 
    self._oprot.writeMessageEnd()
4555 
    self._oprot.trans.flush()
4556 
 
4557 
  def recv_getAllItemstoListOnFba(self, ):
4558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4559 
    if mtype == TMessageType.EXCEPTION:
4560 
      x = TApplicationException()
4561 
      x.read(self._iprot)
4562 
      self._iprot.readMessageEnd()
4563 
      raise x
4564 
    result = getAllItemstoListOnFba_result()
4565 
    result.read(self._iprot)
4566 
    self._iprot.readMessageEnd()
4567 
    if result.success is not None:
4568 
      return result.success
4569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4570 
 
4571 
  def getAllItemstoListOnNonFba(self, ):
4572 
    self.send_getAllItemstoListOnNonFba()
4573 
    return self.recv_getAllItemstoListOnNonFba()
4574 
 
4575 
  def send_getAllItemstoListOnNonFba(self, ):
4576 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4577 
    args = getAllItemstoListOnNonFba_args()
4578 
    args.write(self._oprot)
4579 
    self._oprot.writeMessageEnd()
4580 
    self._oprot.trans.flush()
4581 
 
4582 
  def recv_getAllItemstoListOnNonFba(self, ):
4583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4584 
    if mtype == TMessageType.EXCEPTION:
4585 
      x = TApplicationException()
4586 
      x.read(self._iprot)
4587 
      self._iprot.readMessageEnd()
4588 
      raise x
4589 
    result = getAllItemstoListOnNonFba_result()
4590 
    result.read(self._iprot)
4591 
    self._iprot.readMessageEnd()
4592 
    if result.success is not None:
4593 
      return result.success
4594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4595 
 
8616 vikram.rag 4596 
  def getAllSnapdealListedActiveItems(self, ):
4597 
    self.send_getAllSnapdealListedActiveItems()
4598 
    return self.recv_getAllSnapdealListedActiveItems()
8379 vikram.rag 4599 
 
8616 vikram.rag 4600 
  def send_getAllSnapdealListedActiveItems(self, ):
4601 
    self._oprot.writeMessageBegin('getAllSnapdealListedActiveItems', TMessageType.CALL, self._seqid)
4602 
    args = getAllSnapdealListedActiveItems_args()
4603 
    args.write(self._oprot)
4604 
    self._oprot.writeMessageEnd()
4605 
    self._oprot.trans.flush()
4606 
 
4607 
  def recv_getAllSnapdealListedActiveItems(self, ):
4608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4609 
    if mtype == TMessageType.EXCEPTION:
4610 
      x = TApplicationException()
4611 
      x.read(self._iprot)
4612 
      self._iprot.readMessageEnd()
4613 
      raise x
4614 
    result = getAllSnapdealListedActiveItems_result()
4615 
    result.read(self._iprot)
4616 
    self._iprot.readMessageEnd()
4617 
    if result.success is not None:
4618 
      return result.success
4619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealListedActiveItems failed: unknown result");
4620 
 
8619 kshitij.so 4621 
  def updateAsin(self, item):
4622 
    """
4623 
    Parameters:
4624 
     - item
4625 
    """
4626 
    self.send_updateAsin(item)
4627 
    self.recv_updateAsin()
8616 vikram.rag 4628 
 
8619 kshitij.so 4629 
  def send_updateAsin(self, item):
4630 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4631 
    args = updateAsin_args()
4632 
    args.item = item
4633 
    args.write(self._oprot)
4634 
    self._oprot.writeMessageEnd()
4635 
    self._oprot.trans.flush()
4636 
 
4637 
  def recv_updateAsin(self, ):
4638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4639 
    if mtype == TMessageType.EXCEPTION:
4640 
      x = TApplicationException()
4641 
      x.read(self._iprot)
4642 
      self._iprot.readMessageEnd()
4643 
      raise x
4644 
    result = updateAsin_result()
4645 
    result.read(self._iprot)
4646 
    self._iprot.readMessageEnd()
4647 
    return
4648 
 
4649 
 
5944 mandeep.dh 4650 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4651 
  def __init__(self, handler):
4652 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4653 
    self._processMap["addItem"] = Processor.process_addItem
4654 
    self._processMap["updateItem"] = Processor.process_updateItem
4655 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4656 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4657 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4658 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4659 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4660 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4661 
    self._processMap["getItem"] = Processor.process_getItem
4662 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4663 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4664 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4665 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4666 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4667 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4668 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4669 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4670 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4671 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4672 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4673 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4674 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4675 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4676 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4677 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4678 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4679 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4680 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4681 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4682 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4683 
    self._processMap["addCategory"] = Processor.process_addCategory
4684 
    self._processMap["getCategory"] = Processor.process_getCategory
4685 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4686 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4687 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4688 
    self._processMap["addTag"] = Processor.process_addTag
4689 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4690 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4691 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4692 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4693 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4694 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4695 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4696 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4697 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4698 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4699 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4700 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4701 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4702 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4703 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4704 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4705 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4706 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4707 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4708 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4709 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
5944 mandeep.dh 4710 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4711 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4712 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4713 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4714 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4715 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4716 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4717 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4718 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4719 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4720 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4721 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4722 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4723 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4724 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4725 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4726 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4727 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4728 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4729 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4730 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4731 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4732 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4733 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4734 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4735 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4736 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4737 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4738 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4739 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4740 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4741 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4742 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4743 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4744 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4745 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4746 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4747 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4748 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4749 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4750 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4751 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 4752 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
4753 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
4754 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 4755 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4756 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4757 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4758 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4759 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4760 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4761 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4762 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4763 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4764 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4765 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4766 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4767 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4768 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4769 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4770 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4771 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4772 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8616 vikram.rag 4773 
    self._processMap["getAllSnapdealListedActiveItems"] = Processor.process_getAllSnapdealListedActiveItems
8619 kshitij.so 4774 
    self._processMap["updateAsin"] = Processor.process_updateAsin
5944 mandeep.dh 4775 
 
4776 
  def process(self, iprot, oprot):
4777 
    (name, type, seqid) = iprot.readMessageBegin()
4778 
    if name not in self._processMap:
4779 
      iprot.skip(TType.STRUCT)
4780 
      iprot.readMessageEnd()
4781 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4782 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4783 
      x.write(oprot)
4784 
      oprot.writeMessageEnd()
4785 
      oprot.trans.flush()
4786 
      return
4787 
    else:
4788 
      self._processMap[name](self, seqid, iprot, oprot)
4789 
    return True
4790 
 
4791 
  def process_addItem(self, seqid, iprot, oprot):
4792 
    args = addItem_args()
4793 
    args.read(iprot)
4794 
    iprot.readMessageEnd()
4795 
    result = addItem_result()
4796 
    try:
4797 
      result.success = self._handler.addItem(args.item)
4798 
    except CatalogServiceException, cex:
4799 
      result.cex = cex
4800 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4801 
    result.write(oprot)
4802 
    oprot.writeMessageEnd()
4803 
    oprot.trans.flush()
4804 
 
4805 
  def process_updateItem(self, seqid, iprot, oprot):
4806 
    args = updateItem_args()
4807 
    args.read(iprot)
4808 
    iprot.readMessageEnd()
4809 
    result = updateItem_result()
4810 
    try:
4811 
      result.success = self._handler.updateItem(args.item)
4812 
    except CatalogServiceException, cex:
4813 
      result.cex = cex
4814 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4815 
    result.write(oprot)
4816 
    oprot.writeMessageEnd()
4817 
    oprot.trans.flush()
4818 
 
4819 
  def process_isActive(self, seqid, iprot, oprot):
4820 
    args = isActive_args()
4821 
    args.read(iprot)
4822 
    iprot.readMessageEnd()
4823 
    result = isActive_result()
4824 
    try:
4825 
      result.success = self._handler.isActive(args.itemId)
4826 
    except CatalogServiceException, isex:
4827 
      result.isex = isex
4828 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4829 
    result.write(oprot)
4830 
    oprot.writeMessageEnd()
4831 
    oprot.trans.flush()
4832 
 
7438 amit.gupta 4833 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4834 
    args = getItemsStatus_args()
4835 
    args.read(iprot)
4836 
    iprot.readMessageEnd()
4837 
    result = getItemsStatus_result()
4838 
    try:
4839 
      result.success = self._handler.getItemsStatus(args.itemIds)
4840 
    except CatalogServiceException, isex:
4841 
      result.isex = isex
4842 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4843 
    result.write(oprot)
4844 
    oprot.writeMessageEnd()
4845 
    oprot.trans.flush()
4846 
 
5944 mandeep.dh 4847 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4848 
    args = getItemStatusDescription_args()
4849 
    args.read(iprot)
4850 
    iprot.readMessageEnd()
4851 
    result = getItemStatusDescription_result()
4852 
    try:
4853 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4854 
    except CatalogServiceException, isex:
4855 
      result.isex = isex
4856 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4857 
    result.write(oprot)
4858 
    oprot.writeMessageEnd()
4859 
    oprot.trans.flush()
4860 
 
4861 
  def process_startItemOn(self, seqid, iprot, oprot):
4862 
    args = startItemOn_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = startItemOn_result()
4866 
    try:
4867 
      self._handler.startItemOn(args.item_id, args.timestamp)
4868 
    except CatalogServiceException, cex:
4869 
      result.cex = cex
4870 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4871 
    result.write(oprot)
4872 
    oprot.writeMessageEnd()
4873 
    oprot.trans.flush()
4874 
 
4875 
  def process_retireItemOn(self, seqid, iprot, oprot):
4876 
    args = retireItemOn_args()
4877 
    args.read(iprot)
4878 
    iprot.readMessageEnd()
4879 
    result = retireItemOn_result()
4880 
    try:
4881 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4882 
    except CatalogServiceException, cex:
4883 
      result.cex = cex
4884 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4885 
    result.write(oprot)
4886 
    oprot.writeMessageEnd()
4887 
    oprot.trans.flush()
4888 
 
4889 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4890 
    args = changeItemStatus_args()
4891 
    args.read(iprot)
4892 
    iprot.readMessageEnd()
4893 
    result = changeItemStatus_result()
4894 
    try:
4895 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4896 
    except CatalogServiceException, cex:
4897 
      result.cex = cex
4898 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4899 
    result.write(oprot)
4900 
    oprot.writeMessageEnd()
4901 
    oprot.trans.flush()
4902 
 
4903 
  def process_getItem(self, seqid, iprot, oprot):
4904 
    args = getItem_args()
4905 
    args.read(iprot)
4906 
    iprot.readMessageEnd()
4907 
    result = getItem_result()
4908 
    try:
4909 
      result.success = self._handler.getItem(args.item_id)
4910 
    except CatalogServiceException, cex:
4911 
      result.cex = cex
4912 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4913 
    result.write(oprot)
4914 
    oprot.writeMessageEnd()
4915 
    oprot.trans.flush()
4916 
 
4917 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4918 
    args = getItemsByCatalogId_args()
4919 
    args.read(iprot)
4920 
    iprot.readMessageEnd()
4921 
    result = getItemsByCatalogId_result()
4922 
    try:
4923 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4924 
    except CatalogServiceException, cex:
4925 
      result.cex = cex
4926 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4927 
    result.write(oprot)
4928 
    oprot.writeMessageEnd()
4929 
    oprot.trans.flush()
4930 
 
4931 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4932 
    args = getValidItemsByCatalogId_args()
4933 
    args.read(iprot)
4934 
    iprot.readMessageEnd()
4935 
    result = getValidItemsByCatalogId_result()
4936 
    try:
4937 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4938 
    except CatalogServiceException, cex:
4939 
      result.cex = cex
4940 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4941 
    result.write(oprot)
4942 
    oprot.writeMessageEnd()
4943 
    oprot.trans.flush()
4944 
 
4945 
  def process_getAllItems(self, seqid, iprot, oprot):
4946 
    args = getAllItems_args()
4947 
    args.read(iprot)
4948 
    iprot.readMessageEnd()
4949 
    result = getAllItems_result()
4950 
    try:
4951 
      result.success = self._handler.getAllItems(args.isActive)
4952 
    except CatalogServiceException, cex:
4953 
      result.cex = cex
4954 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4955 
    result.write(oprot)
4956 
    oprot.writeMessageEnd()
4957 
    oprot.trans.flush()
4958 
 
4959 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4960 
    args = getAllItemsByStatus_args()
4961 
    args.read(iprot)
4962 
    iprot.readMessageEnd()
4963 
    result = getAllItemsByStatus_result()
4964 
    try:
4965 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4966 
    except CatalogServiceException, cex:
4967 
      result.cex = cex
4968 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4969 
    result.write(oprot)
4970 
    oprot.writeMessageEnd()
4971 
    oprot.trans.flush()
4972 
 
4973 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4974 
    args = markItemAsContentComplete_args()
4975 
    args.read(iprot)
4976 
    iprot.readMessageEnd()
4977 
    result = markItemAsContentComplete_result()
4978 
    try:
4979 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4980 
    except CatalogServiceException, cex:
4981 
      result.cex = cex
4982 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
4986 
 
4987 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4988 
    args = getAllItemsInRange_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = getAllItemsInRange_result()
4992 
    try:
4993 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4994 
    except CatalogServiceException, cex:
4995 
      result.cex = cex
4996 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4997 
    result.write(oprot)
4998 
    oprot.writeMessageEnd()
4999 
    oprot.trans.flush()
5000 
 
5001 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5002 
    args = getAllItemsByStatusInRange_args()
5003 
    args.read(iprot)
5004 
    iprot.readMessageEnd()
5005 
    result = getAllItemsByStatusInRange_result()
5006 
    try:
5007 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5008 
    except CatalogServiceException, cex:
5009 
      result.cex = cex
5010 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5011 
    result.write(oprot)
5012 
    oprot.writeMessageEnd()
5013 
    oprot.trans.flush()
5014 
 
5015 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5016 
    args = getItemCountByStatus_args()
5017 
    args.read(iprot)
5018 
    iprot.readMessageEnd()
5019 
    result = getItemCountByStatus_result()
5020 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5021 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5022 
    result.write(oprot)
5023 
    oprot.writeMessageEnd()
5024 
    oprot.trans.flush()
5025 
 
5026 
  def process_getBestSellers(self, seqid, iprot, oprot):
5027 
    args = getBestSellers_args()
5028 
    args.read(iprot)
5029 
    iprot.readMessageEnd()
5030 
    result = getBestSellers_result()
5031 
    try:
5032 
      result.success = self._handler.getBestSellers()
5033 
    except CatalogServiceException, isex:
5034 
      result.isex = isex
5035 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
5040 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5041 
    args = getBestSellersCatalogIds_args()
5042 
    args.read(iprot)
5043 
    iprot.readMessageEnd()
5044 
    result = getBestSellersCatalogIds_result()
5045 
    try:
5046 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5047 
    except CatalogServiceException, cex:
5048 
      result.cex = cex
5049 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5050 
    result.write(oprot)
5051 
    oprot.writeMessageEnd()
5052 
    oprot.trans.flush()
5053 
 
5054 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5055 
    args = getBestSellersCount_args()
5056 
    args.read(iprot)
5057 
    iprot.readMessageEnd()
5058 
    result = getBestSellersCount_result()
5059 
    try:
5060 
      result.success = self._handler.getBestSellersCount()
5061 
    except CatalogServiceException, cex:
5062 
      result.cex = cex
5063 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5064 
    result.write(oprot)
5065 
    oprot.writeMessageEnd()
5066 
    oprot.trans.flush()
5067 
 
5068 
  def process_getBestDeals(self, seqid, iprot, oprot):
5069 
    args = getBestDeals_args()
5070 
    args.read(iprot)
5071 
    iprot.readMessageEnd()
5072 
    result = getBestDeals_result()
5073 
    try:
5074 
      result.success = self._handler.getBestDeals()
5075 
    except CatalogServiceException, isex:
5076 
      result.isex = isex
5077 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5078 
    result.write(oprot)
5079 
    oprot.writeMessageEnd()
5080 
    oprot.trans.flush()
5081 
 
5082 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5083 
    args = getBestDealsCatalogIds_args()
5084 
    args.read(iprot)
5085 
    iprot.readMessageEnd()
5086 
    result = getBestDealsCatalogIds_result()
5087 
    try:
5088 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5089 
    except CatalogServiceException, cex:
5090 
      result.cex = cex
5091 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5092 
    result.write(oprot)
5093 
    oprot.writeMessageEnd()
5094 
    oprot.trans.flush()
5095 
 
5096 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5097 
    args = getBestDealsCount_args()
5098 
    args.read(iprot)
5099 
    iprot.readMessageEnd()
5100 
    result = getBestDealsCount_result()
5101 
    try:
5102 
      result.success = self._handler.getBestDealsCount()
5103 
    except CatalogServiceException, cex:
5104 
      result.cex = cex
5105 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5106 
    result.write(oprot)
5107 
    oprot.writeMessageEnd()
5108 
    oprot.trans.flush()
5109 
 
5110 
  def process_getComingSoon(self, seqid, iprot, oprot):
5111 
    args = getComingSoon_args()
5112 
    args.read(iprot)
5113 
    iprot.readMessageEnd()
5114 
    result = getComingSoon_result()
5115 
    try:
5116 
      result.success = self._handler.getComingSoon()
5117 
    except CatalogServiceException, isex:
5118 
      result.isex = isex
5119 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5120 
    result.write(oprot)
5121 
    oprot.writeMessageEnd()
5122 
    oprot.trans.flush()
5123 
 
5124 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5125 
    args = getComingSoonCatalogIds_args()
5126 
    args.read(iprot)
5127 
    iprot.readMessageEnd()
5128 
    result = getComingSoonCatalogIds_result()
5129 
    try:
5130 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5131 
    except CatalogServiceException, cex:
5132 
      result.cex = cex
5133 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
5137 
 
5138 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5139 
    args = getComingSoonCount_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = getComingSoonCount_result()
5143 
    try:
5144 
      result.success = self._handler.getComingSoonCount()
5145 
    except CatalogServiceException, cex:
5146 
      result.cex = cex
5147 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
5152 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5153 
    args = getLatestArrivals_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = getLatestArrivals_result()
5157 
    try:
5158 
      result.success = self._handler.getLatestArrivals()
5159 
    except CatalogServiceException, isex:
5160 
      result.isex = isex
5161 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
5166 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5167 
    args = getLatestArrivalsCatalogIds_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = getLatestArrivalsCatalogIds_result()
5171 
    try:
5172 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5173 
    except CatalogServiceException, cex:
5174 
      result.cex = cex
5175 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
5180 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5181 
    args = getLatestArrivalsCount_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = getLatestArrivalsCount_result()
5185 
    try:
5186 
      result.success = self._handler.getLatestArrivalsCount()
5187 
    except CatalogServiceException, cex:
5188 
      result.cex = cex
5189 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
5193 
 
5194 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5195 
    args = generateNewEntityID_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = generateNewEntityID_result()
5199 
    result.success = self._handler.generateNewEntityID()
5200 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
5204 
 
5205 
  def process_addCategory(self, seqid, iprot, oprot):
5206 
    args = addCategory_args()
5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
5209 
    result = addCategory_result()
5210 
    result.success = self._handler.addCategory(args.category)
5211 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
5215 
 
5216 
  def process_getCategory(self, seqid, iprot, oprot):
5217 
    args = getCategory_args()
5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
5220 
    result = getCategory_result()
5221 
    result.success = self._handler.getCategory(args.id)
5222 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5223 
    result.write(oprot)
5224 
    oprot.writeMessageEnd()
5225 
    oprot.trans.flush()
5226 
 
5227 
  def process_getAllCategories(self, seqid, iprot, oprot):
5228 
    args = getAllCategories_args()
5229 
    args.read(iprot)
5230 
    iprot.readMessageEnd()
5231 
    result = getAllCategories_result()
5232 
    result.success = self._handler.getAllCategories()
5233 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5234 
    result.write(oprot)
5235 
    oprot.writeMessageEnd()
5236 
    oprot.trans.flush()
5237 
 
5238 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5239 
    args = getAllSimilarItems_args()
5240 
    args.read(iprot)
5241 
    iprot.readMessageEnd()
5242 
    result = getAllSimilarItems_result()
5243 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5244 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5245 
    result.write(oprot)
5246 
    oprot.writeMessageEnd()
5247 
    oprot.trans.flush()
5248 
 
5249 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5250 
    args = addSimilarItem_args()
5251 
    args.read(iprot)
5252 
    iprot.readMessageEnd()
5253 
    result = addSimilarItem_result()
5254 
    try:
5255 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5256 
    except CatalogServiceException, cex:
5257 
      result.cex = cex
5258 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5259 
    result.write(oprot)
5260 
    oprot.writeMessageEnd()
5261 
    oprot.trans.flush()
5262 
 
6512 kshitij.so 5263 
  def process_addTag(self, seqid, iprot, oprot):
5264 
    args = addTag_args()
5265 
    args.read(iprot)
5266 
    iprot.readMessageEnd()
5267 
    result = addTag_result()
5268 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5269 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5270 
    result.write(oprot)
5271 
    oprot.writeMessageEnd()
5272 
    oprot.trans.flush()
5273 
 
5274 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5275 
    args = deleteEntityTag_args()
5276 
    args.read(iprot)
5277 
    iprot.readMessageEnd()
5278 
    result = deleteEntityTag_result()
5279 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5280 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5281 
    result.write(oprot)
5282 
    oprot.writeMessageEnd()
5283 
    oprot.trans.flush()
5284 
 
5285 
  def process_deleteTag(self, seqid, iprot, oprot):
5286 
    args = deleteTag_args()
5287 
    args.read(iprot)
5288 
    iprot.readMessageEnd()
5289 
    result = deleteTag_result()
5290 
    result.success = self._handler.deleteTag(args.displayName)
5291 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5292 
    result.write(oprot)
5293 
    oprot.writeMessageEnd()
5294 
    oprot.trans.flush()
5295 
 
5296 
  def process_getAllTags(self, seqid, iprot, oprot):
5297 
    args = getAllTags_args()
5298 
    args.read(iprot)
5299 
    iprot.readMessageEnd()
5300 
    result = getAllTags_result()
5301 
    result.success = self._handler.getAllTags()
5302 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5303 
    result.write(oprot)
5304 
    oprot.writeMessageEnd()
5305 
    oprot.trans.flush()
5306 
 
5307 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5308 
    args = getAllEntitiesByTagName_args()
5309 
    args.read(iprot)
5310 
    iprot.readMessageEnd()
5311 
    result = getAllEntitiesByTagName_result()
5312 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5313 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5314 
    result.write(oprot)
5315 
    oprot.writeMessageEnd()
5316 
    oprot.trans.flush()
5317 
 
6845 amit.gupta 5318 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5319 
    args = getAllEntityTags_args()
5320 
    args.read(iprot)
5321 
    iprot.readMessageEnd()
5322 
    result = getAllEntityTags_result()
5323 
    result.success = self._handler.getAllEntityTags()
5324 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5325 
    result.write(oprot)
5326 
    oprot.writeMessageEnd()
5327 
    oprot.trans.flush()
5328 
 
6850 kshitij.so 5329 
  def process_addBanner(self, seqid, iprot, oprot):
5330 
    args = addBanner_args()
5331 
    args.read(iprot)
5332 
    iprot.readMessageEnd()
5333 
    result = addBanner_result()
8590 kshitij.so 5334 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5335 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
5339 
 
8579 kshitij.so 5340 
  def process_updateBanner(self, seqid, iprot, oprot):
5341 
    args = updateBanner_args()
5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
5344 
    result = updateBanner_result()
5345 
    result.success = self._handler.updateBanner(args.banner)
5346 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
5350 
 
6850 kshitij.so 5351 
  def process_getAllBanners(self, seqid, iprot, oprot):
5352 
    args = getAllBanners_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = getAllBanners_result()
5356 
    result.success = self._handler.getAllBanners()
5357 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5358 
    result.write(oprot)
5359 
    oprot.writeMessageEnd()
5360 
    oprot.trans.flush()
5361 
 
5362 
  def process_deleteBanner(self, seqid, iprot, oprot):
5363 
    args = deleteBanner_args()
5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
5366 
    result = deleteBanner_result()
5367 
    result.success = self._handler.deleteBanner(args.bannerName)
5368 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
5373 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5374 
    args = getBannerDetails_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = getBannerDetails_result()
5378 
    result.success = self._handler.getBannerDetails(args.bannerName)
5379 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
5384 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5385 
    args = getActiveBanners_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = getActiveBanners_result()
5389 
    result.success = self._handler.getActiveBanners()
5390 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
5394 
 
6849 kshitij.so 5395 
  def process_addBannerMap(self, seqid, iprot, oprot):
5396 
    args = addBannerMap_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = addBannerMap_result()
8579 kshitij.so 5400 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5401 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5402 
    result.write(oprot)
5403 
    oprot.writeMessageEnd()
5404 
    oprot.trans.flush()
5405 
 
8579 kshitij.so 5406 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5407 
    args = updateBannerMap_args()
5408 
    args.read(iprot)
5409 
    iprot.readMessageEnd()
5410 
    result = updateBannerMap_result()
5411 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5412 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5413 
    result.write(oprot)
5414 
    oprot.writeMessageEnd()
5415 
    oprot.trans.flush()
5416 
 
6849 kshitij.so 5417 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5418 
    args = deleteBannerMap_args()
5419 
    args.read(iprot)
5420 
    iprot.readMessageEnd()
5421 
    result = deleteBannerMap_result()
5422 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5423 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5424 
    result.write(oprot)
5425 
    oprot.writeMessageEnd()
5426 
    oprot.trans.flush()
5427 
 
5428 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5429 
    args = getBannerMapDetails_args()
5430 
    args.read(iprot)
5431 
    iprot.readMessageEnd()
5432 
    result = getBannerMapDetails_result()
5433 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
5434 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5435 
    result.write(oprot)
5436 
    oprot.writeMessageEnd()
5437 
    oprot.trans.flush()
5438 
 
8579 kshitij.so 5439 
  def process_addBannerUri(self, seqid, iprot, oprot):
5440 
    args = addBannerUri_args()
5441 
    args.read(iprot)
5442 
    iprot.readMessageEnd()
5443 
    result = addBannerUri_result()
5444 
    self._handler.addBannerUri(args.bannerUriMappings)
5445 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5446 
    result.write(oprot)
5447 
    oprot.writeMessageEnd()
5448 
    oprot.trans.flush()
5449 
 
5450 
  def process_getUriMapping(self, seqid, iprot, oprot):
5451 
    args = getUriMapping_args()
5452 
    args.read(iprot)
5453 
    iprot.readMessageEnd()
5454 
    result = getUriMapping_result()
5455 
    result.success = self._handler.getUriMapping(args.bannerName)
5456 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5457 
    result.write(oprot)
5458 
    oprot.writeMessageEnd()
5459 
    oprot.trans.flush()
5460 
 
5461 
  def process_addCampaign(self, seqid, iprot, oprot):
5462 
    args = addCampaign_args()
5463 
    args.read(iprot)
5464 
    iprot.readMessageEnd()
5465 
    result = addCampaign_result()
5466 
    self._handler.addCampaign(args.campaign)
5467 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5468 
    result.write(oprot)
5469 
    oprot.writeMessageEnd()
5470 
    oprot.trans.flush()
5471 
 
5472 
  def process_getCampaigns(self, seqid, iprot, oprot):
5473 
    args = getCampaigns_args()
5474 
    args.read(iprot)
5475 
    iprot.readMessageEnd()
5476 
    result = getCampaigns_result()
5477 
    result.success = self._handler.getCampaigns(args.campaignName)
5478 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5479 
    result.write(oprot)
5480 
    oprot.writeMessageEnd()
5481 
    oprot.trans.flush()
5482 
 
5483 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5484 
    args = deleteCampaign_args()
5485 
    args.read(iprot)
5486 
    iprot.readMessageEnd()
5487 
    result = deleteCampaign_result()
5488 
    self._handler.deleteCampaign(args.campaignId)
5489 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5490 
    result.write(oprot)
5491 
    oprot.writeMessageEnd()
5492 
    oprot.trans.flush()
5493 
 
5494 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5495 
    args = getAllCampaigns_args()
5496 
    args.read(iprot)
5497 
    iprot.readMessageEnd()
5498 
    result = getAllCampaigns_result()
5499 
    result.success = self._handler.getAllCampaigns()
5500 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5501 
    result.write(oprot)
5502 
    oprot.writeMessageEnd()
5503 
    oprot.trans.flush()
5504 
 
5944 mandeep.dh 5505 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5506 
    args = deleteSimilarItem_args()
5507 
    args.read(iprot)
5508 
    iprot.readMessageEnd()
5509 
    result = deleteSimilarItem_result()
5510 
    try:
5511 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5512 
    except CatalogServiceException, cex:
5513 
      result.cex = cex
5514 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5515 
    result.write(oprot)
5516 
    oprot.writeMessageEnd()
5517 
    oprot.trans.flush()
5518 
 
5519 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5520 
    args = checkSimilarItem_args()
5521 
    args.read(iprot)
5522 
    iprot.readMessageEnd()
5523 
    result = checkSimilarItem_result()
5524 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5525 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5526 
    result.write(oprot)
5527 
    oprot.writeMessageEnd()
5528 
    oprot.trans.flush()
5529 
 
5530 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5531 
    args = validateRiskyStatus_args()
5532 
    args.read(iprot)
5533 
    iprot.readMessageEnd()
5534 
    result = validateRiskyStatus_result()
5535 
    self._handler.validateRiskyStatus(args.itemId)
5536 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5537 
    result.write(oprot)
5538 
    oprot.writeMessageEnd()
5539 
    oprot.trans.flush()
5540 
 
5541 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5542 
    args = changeItemRiskyFlag_args()
5543 
    args.read(iprot)
5544 
    iprot.readMessageEnd()
5545 
    result = changeItemRiskyFlag_result()
5546 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5547 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5548 
    result.write(oprot)
5549 
    oprot.writeMessageEnd()
5550 
    oprot.trans.flush()
5551 
 
5552 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5553 
    args = getItemsByRiskyFlag_args()
5554 
    args.read(iprot)
5555 
    iprot.readMessageEnd()
5556 
    result = getItemsByRiskyFlag_result()
5557 
    result.success = self._handler.getItemsByRiskyFlag()
5558 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5559 
    result.write(oprot)
5560 
    oprot.writeMessageEnd()
5561 
    oprot.trans.flush()
5562 
 
5563 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5564 
    args = getItemsForMasterSheet_args()
5565 
    args.read(iprot)
5566 
    iprot.readMessageEnd()
5567 
    result = getItemsForMasterSheet_result()
5568 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5569 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5570 
    result.write(oprot)
5571 
    oprot.writeMessageEnd()
5572 
    oprot.trans.flush()
5573 
 
5574 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5575 
    args = getSimilarItemsCatalogIds_args()
5576 
    args.read(iprot)
5577 
    iprot.readMessageEnd()
5578 
    result = getSimilarItemsCatalogIds_result()
5579 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5580 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
5585 
  def process_addProductNotification(self, seqid, iprot, oprot):
5586 
    args = addProductNotification_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = addProductNotification_result()
5590 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5591 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
5595 
 
5596 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5597 
    args = sendProductNotifications_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = sendProductNotifications_result()
5601 
    result.success = self._handler.sendProductNotifications()
5602 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
5607 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5608 
    args = getAllBrandsByCategory_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = getAllBrandsByCategory_result()
5612 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5613 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5614 
    result.write(oprot)
5615 
    oprot.writeMessageEnd()
5616 
    oprot.trans.flush()
5617 
 
5618 
  def process_getAllBrands(self, seqid, iprot, oprot):
5619 
    args = getAllBrands_args()
5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
5622 
    result = getAllBrands_result()
5623 
    result.success = self._handler.getAllBrands()
5624 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5625 
    result.write(oprot)
5626 
    oprot.writeMessageEnd()
5627 
    oprot.trans.flush()
5628 
 
5629 
  def process_getAllSources(self, seqid, iprot, oprot):
5630 
    args = getAllSources_args()
5631 
    args.read(iprot)
5632 
    iprot.readMessageEnd()
5633 
    result = getAllSources_result()
5634 
    result.success = self._handler.getAllSources()
5635 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5636 
    result.write(oprot)
5637 
    oprot.writeMessageEnd()
5638 
    oprot.trans.flush()
5639 
 
5640 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5641 
    args = getItemPricingBySource_args()
5642 
    args.read(iprot)
5643 
    iprot.readMessageEnd()
5644 
    result = getItemPricingBySource_result()
5645 
    try:
5646 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5647 
    except CatalogServiceException, cex:
5648 
      result.cex = cex
5649 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5650 
    result.write(oprot)
5651 
    oprot.writeMessageEnd()
5652 
    oprot.trans.flush()
5653 
 
5654 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5655 
    args = addSourceItemPricing_args()
5656 
    args.read(iprot)
5657 
    iprot.readMessageEnd()
5658 
    result = addSourceItemPricing_result()
5659 
    try:
5660 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5661 
    except CatalogServiceException, cex:
5662 
      result.cex = cex
5663 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5664 
    result.write(oprot)
5665 
    oprot.writeMessageEnd()
5666 
    oprot.trans.flush()
5667 
 
5668 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5669 
    args = getAllSourcePricing_args()
5670 
    args.read(iprot)
5671 
    iprot.readMessageEnd()
5672 
    result = getAllSourcePricing_result()
5673 
    try:
5674 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5675 
    except CatalogServiceException, cex:
5676 
      result.cex = cex
5677 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5678 
    result.write(oprot)
5679 
    oprot.writeMessageEnd()
5680 
    oprot.trans.flush()
5681 
 
5682 
  def process_getItemForSource(self, seqid, iprot, oprot):
5683 
    args = getItemForSource_args()
5684 
    args.read(iprot)
5685 
    iprot.readMessageEnd()
5686 
    result = getItemForSource_result()
5687 
    try:
5688 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5689 
    except CatalogServiceException, cex:
5690 
      result.cex = cex
5691 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5692 
    result.write(oprot)
5693 
    oprot.writeMessageEnd()
5694 
    oprot.trans.flush()
5695 
 
5696 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5697 
    args = searchItemsInRange_args()
5698 
    args.read(iprot)
5699 
    iprot.readMessageEnd()
5700 
    result = searchItemsInRange_result()
5701 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5702 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5703 
    result.write(oprot)
5704 
    oprot.writeMessageEnd()
5705 
    oprot.trans.flush()
5706 
 
5707 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5708 
    args = getSearchResultCount_args()
5709 
    args.read(iprot)
5710 
    iprot.readMessageEnd()
5711 
    result = getSearchResultCount_result()
5712 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5713 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5714 
    result.write(oprot)
5715 
    oprot.writeMessageEnd()
5716 
    oprot.trans.flush()
5717 
 
5718 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5719 
    args = getProductNotifications_args()
5720 
    args.read(iprot)
5721 
    iprot.readMessageEnd()
5722 
    result = getProductNotifications_result()
5723 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5724 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5725 
    result.write(oprot)
5726 
    oprot.writeMessageEnd()
5727 
    oprot.trans.flush()
5728 
 
5729 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5730 
    args = getProductNotificationRequestCount_args()
5731 
    args.read(iprot)
5732 
    iprot.readMessageEnd()
5733 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5734 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5735 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5736 
    result.write(oprot)
5737 
    oprot.writeMessageEnd()
5738 
    oprot.trans.flush()
5739 
 
5740 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5741 
    args = addAuthorizationLog_args()
5742 
    args.read(iprot)
5743 
    iprot.readMessageEnd()
5744 
    result = addAuthorizationLog_result()
5745 
    try:
5746 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5747 
    except CatalogServiceException, cex:
5748 
      result.cex = cex
5749 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5750 
    result.write(oprot)
5751 
    oprot.writeMessageEnd()
5752 
    oprot.trans.flush()
5753 
 
5754 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5755 
    args = addupdateVoucherForItem_args()
5756 
    args.read(iprot)
5757 
    iprot.readMessageEnd()
5758 
    result = addupdateVoucherForItem_result()
5759 
    try:
5760 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5761 
    except CatalogServiceException, cex:
5762 
      result.cex = cex
5763 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5764 
    result.write(oprot)
5765 
    oprot.writeMessageEnd()
5766 
    oprot.trans.flush()
5767 
 
5768 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5769 
    args = deleteVoucherForItem_args()
5770 
    args.read(iprot)
5771 
    iprot.readMessageEnd()
5772 
    result = deleteVoucherForItem_result()
5773 
    try:
5774 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5775 
    except CatalogServiceException, cex:
5776 
      result.cex = cex
5777 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5778 
    result.write(oprot)
5779 
    oprot.writeMessageEnd()
5780 
    oprot.trans.flush()
5781 
 
5782 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5783 
    args = getVoucherAmount_args()
5784 
    args.read(iprot)
5785 
    iprot.readMessageEnd()
5786 
    result = getVoucherAmount_result()
5787 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5788 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5789 
    result.write(oprot)
5790 
    oprot.writeMessageEnd()
5791 
    oprot.trans.flush()
5792 
 
5793 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5794 
    args = getAllItemVouchers_args()
5795 
    args.read(iprot)
5796 
    iprot.readMessageEnd()
5797 
    result = getAllItemVouchers_result()
5798 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5799 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
5804 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5805 
    args = isValidCatalogItemId_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = isValidCatalogItemId_result()
5809 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5810 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5811 
    result.write(oprot)
5812 
    oprot.writeMessageEnd()
5813 
    oprot.trans.flush()
5814 
 
6039 amit.gupta 5815 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5816 
    args = getVatPercentageForItem_args()
5817 
    args.read(iprot)
5818 
    iprot.readMessageEnd()
5819 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5820 
    try:
5821 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5822 
    except CatalogServiceException, cex:
5823 
      result.cex = cex
6039 amit.gupta 5824 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5825 
    result.write(oprot)
5826 
    oprot.writeMessageEnd()
5827 
    oprot.trans.flush()
5944 mandeep.dh 5828 
 
6039 amit.gupta 5829 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5830 
    args = getVatAmountForItem_args()
5831 
    args.read(iprot)
5832 
    iprot.readMessageEnd()
5833 
    result = getVatAmountForItem_result()
5834 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5835 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5836 
    result.write(oprot)
5837 
    oprot.writeMessageEnd()
5838 
    oprot.trans.flush()
5839 
 
6531 vikram.rag 5840 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5841 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5842 
    args.read(iprot)
5843 
    iprot.readMessageEnd()
5844 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5845 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5846 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5847 
    result.write(oprot)
5848 
    oprot.writeMessageEnd()
5849 
    oprot.trans.flush()
6039 amit.gupta 5850 
 
6821 amar.kumar 5851 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5852 
    args = getAllAliveItems_args()
5853 
    args.read(iprot)
5854 
    iprot.readMessageEnd()
5855 
    result = getAllAliveItems_result()
5856 
    result.success = self._handler.getAllAliveItems()
5857 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
6805 anupam.sin 5862 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5863 
    args = getInsuranceAmount_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = getInsuranceAmount_result()
6921 anupam.sin 5867 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5868 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
6531 vikram.rag 5872 
 
6805 anupam.sin 5873 
  def process_getInsurer(self, seqid, iprot, oprot):
5874 
    args = getInsurer_args()
5875 
    args.read(iprot)
5876 
    iprot.readMessageEnd()
5877 
    result = getInsurer_result()
5878 
    result.success = self._handler.getInsurer(args.insurerId)
5879 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
6838 vikram.rag 5884 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5885 
    args = getAllInsurers_args()
5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
5888 
    result = getAllInsurers_result()
5889 
    result.success = self._handler.getAllInsurers()
5890 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5891 
    result.write(oprot)
5892 
    oprot.writeMessageEnd()
5893 
    oprot.trans.flush()
6805 anupam.sin 5894 
 
6962 rajveer 5895 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5896 
    args = updateInsuranceDeclaredAmount_args()
5897 
    args.read(iprot)
5898 
    iprot.readMessageEnd()
5899 
    result = updateInsuranceDeclaredAmount_result()
5900 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5901 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5902 
    result.write(oprot)
5903 
    oprot.writeMessageEnd()
5904 
    oprot.trans.flush()
6838 vikram.rag 5905 
 
7190 amar.kumar 5906 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5907 
    args = getFreebieForItem_args()
5908 
    args.read(iprot)
5909 
    iprot.readMessageEnd()
5910 
    result = getFreebieForItem_result()
5911 
    result.success = self._handler.getFreebieForItem(args.itemId)
5912 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5913 
    result.write(oprot)
5914 
    oprot.writeMessageEnd()
5915 
    oprot.trans.flush()
6962 rajveer 5916 
 
7190 amar.kumar 5917 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5918 
    args = addOrUpdateFreebieForItem_args()
5919 
    args.read(iprot)
5920 
    iprot.readMessageEnd()
5921 
    result = addOrUpdateFreebieForItem_result()
5922 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5923 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
5927 
 
7272 amit.gupta 5928 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5929 
    args = addOrUpdateBrandInfo_args()
5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
5932 
    result = addOrUpdateBrandInfo_result()
5933 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5934 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5935 
    result.write(oprot)
5936 
    oprot.writeMessageEnd()
5937 
    oprot.trans.flush()
5938 
 
5939 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5940 
    args = getBrandInfo_args()
5941 
    args.read(iprot)
5942 
    iprot.readMessageEnd()
5943 
    result = getBrandInfo_result()
5944 
    result.success = self._handler.getBrandInfo()
5945 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
7256 rajveer 5950 
  def process_getStorePricing(self, seqid, iprot, oprot):
5951 
    args = getStorePricing_args()
5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
5954 
    result = getStorePricing_result()
5955 
    result.success = self._handler.getStorePricing(args.itemId)
5956 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
7190 amar.kumar 5960 
 
7306 rajveer 5961 
  def process_getStorePricings(self, seqid, iprot, oprot):
5962 
    args = getStorePricings_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = getStorePricings_result()
5966 
    result.success = self._handler.getStorePricings(args.itemIds)
5967 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5968 
    result.write(oprot)
5969 
    oprot.writeMessageEnd()
5970 
    oprot.trans.flush()
5971 
 
7265 rajveer 5972 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5973 
    args = updateStorePricing_args()
5974 
    args.read(iprot)
5975 
    iprot.readMessageEnd()
5976 
    result = updateStorePricing_result()
7382 rajveer 5977 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5978 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
7256 rajveer 5982 
 
7281 kshitij.so 5983 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5984 
    args = getAllAmazonListedItems_args()
5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
5987 
    result = getAllAmazonListedItems_result()
5988 
    result.success = self._handler.getAllAmazonListedItems()
5989 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
7265 rajveer 5993 
 
8619 kshitij.so 5994 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
5995 
    args = searchAmazonItems_args()
5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
5998 
    result = searchAmazonItems_result()
5999 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6000 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6001 
    result.write(oprot)
6002 
    oprot.writeMessageEnd()
6003 
    oprot.trans.flush()
6004 
 
6005 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6006 
    args = getAmazonSearchResultCount_args()
6007 
    args.read(iprot)
6008 
    iprot.readMessageEnd()
6009 
    result = getAmazonSearchResultCount_result()
6010 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6011 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
6016 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6017 
    args = getCountForAmazonlistedItems_args()
6018 
    args.read(iprot)
6019 
    iprot.readMessageEnd()
6020 
    result = getCountForAmazonlistedItems_result()
6021 
    result.success = self._handler.getCountForAmazonlistedItems()
6022 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6023 
    result.write(oprot)
6024 
    oprot.writeMessageEnd()
6025 
    oprot.trans.flush()
6026 
 
7281 kshitij.so 6027 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6028 
    args = getAmazonItemDetails_args()
6029 
    args.read(iprot)
6030 
    iprot.readMessageEnd()
6031 
    result = getAmazonItemDetails_result()
6032 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6033 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6034 
    result.write(oprot)
6035 
    oprot.writeMessageEnd()
6036 
    oprot.trans.flush()
6037 
 
6038 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6039 
    args = updateAmazonItemDetails_args()
6040 
    args.read(iprot)
6041 
    iprot.readMessageEnd()
6042 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6043 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6044 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6045 
    result.write(oprot)
6046 
    oprot.writeMessageEnd()
6047 
    oprot.trans.flush()
6048 
 
6049 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6050 
    args = addAmazonItem_args()
6051 
    args.read(iprot)
6052 
    iprot.readMessageEnd()
6053 
    result = addAmazonItem_result()
6054 
    self._handler.addAmazonItem(args.amazonlisted)
6055 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6056 
    result.write(oprot)
6057 
    oprot.writeMessageEnd()
6058 
    oprot.trans.flush()
6059 
 
7291 vikram.rag 6060 
  def process_getAsinItems(self, seqid, iprot, oprot):
6061 
    args = getAsinItems_args()
6062 
    args.read(iprot)
6063 
    iprot.readMessageEnd()
6064 
    result = getAsinItems_result()
6065 
    result.success = self._handler.getAsinItems()
6066 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6067 
    result.write(oprot)
6068 
    oprot.writeMessageEnd()
6069 
    oprot.trans.flush()
7281 kshitij.so 6070 
 
7291 vikram.rag 6071 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6072 
    args = getAllFbaListedItems_args()
6073 
    args.read(iprot)
6074 
    iprot.readMessageEnd()
6075 
    result = getAllFbaListedItems_result()
6076 
    result.success = self._handler.getAllFbaListedItems()
6077 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6078 
    result.write(oprot)
6079 
    oprot.writeMessageEnd()
6080 
    oprot.trans.flush()
6081 
 
6082 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6083 
    args = getAllNonFbaListedItems_args()
6084 
    args.read(iprot)
6085 
    iprot.readMessageEnd()
6086 
    result = getAllNonFbaListedItems_result()
6087 
    result.success = self._handler.getAllNonFbaListedItems()
6088 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6089 
    result.write(oprot)
6090 
    oprot.writeMessageEnd()
6091 
    oprot.trans.flush()
6092 
 
7460 kshitij.so 6093 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6094 
    args = updateItemInventory_args()
6095 
    args.read(iprot)
6096 
    iprot.readMessageEnd()
6097 
    result = updateItemInventory_result()
6098 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6099 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6100 
    result.write(oprot)
6101 
    oprot.writeMessageEnd()
6102 
    oprot.trans.flush()
7291 vikram.rag 6103 
 
7770 kshitij.so 6104 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6105 
    args = updateTimestampForAmazonFeeds_args()
6106 
    args.read(iprot)
6107 
    iprot.readMessageEnd()
6108 
    result = updateTimestampForAmazonFeeds_result()
6109 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6110 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6111 
    result.write(oprot)
6112 
    oprot.writeMessageEnd()
6113 
    oprot.trans.flush()
7460 kshitij.so 6114 
 
7897 amar.kumar 6115 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6116 
    args = getAllParentCategories_args()
6117 
    args.read(iprot)
6118 
    iprot.readMessageEnd()
6119 
    result = getAllParentCategories_result()
6120 
    result.success = self._handler.getAllParentCategories()
6121 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6122 
    result.write(oprot)
6123 
    oprot.writeMessageEnd()
6124 
    oprot.trans.flush()
7770 kshitij.so 6125 
 
7977 kshitij.so 6126 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6127 
    args = addPageViewEvent_args()
6128 
    args.read(iprot)
6129 
    iprot.readMessageEnd()
6130 
    result = addPageViewEvent_result()
6131 
    self._handler.addPageViewEvent(args.pageViewEvents)
6132 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6133 
    result.write(oprot)
6134 
    oprot.writeMessageEnd()
6135 
    oprot.trans.flush()
7897 amar.kumar 6136 
 
7977 kshitij.so 6137 
  def process_addCartEvent(self, seqid, iprot, oprot):
6138 
    args = addCartEvent_args()
6139 
    args.read(iprot)
6140 
    iprot.readMessageEnd()
6141 
    result = addCartEvent_result()
6142 
    self._handler.addCartEvent(args.cartEvents)
6143 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6144 
    result.write(oprot)
6145 
    oprot.writeMessageEnd()
6146 
    oprot.trans.flush()
6147 
 
8182 amar.kumar 6148 
  def process_addEbayItem(self, seqid, iprot, oprot):
6149 
    args = addEbayItem_args()
6150 
    args.read(iprot)
6151 
    iprot.readMessageEnd()
6152 
    result = addEbayItem_result()
6153 
    self._handler.addEbayItem(args.ebayItem)
6154 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6155 
    result.write(oprot)
6156 
    oprot.writeMessageEnd()
6157 
    oprot.trans.flush()
6158 
 
6159 
  def process_getEbayItem(self, seqid, iprot, oprot):
6160 
    args = getEbayItem_args()
6161 
    args.read(iprot)
6162 
    iprot.readMessageEnd()
6163 
    result = getEbayItem_result()
6164 
    result.success = self._handler.getEbayItem(args.listingId)
6165 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6166 
    result.write(oprot)
6167 
    oprot.writeMessageEnd()
6168 
    oprot.trans.flush()
6169 
 
6170 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6171 
    args = updateEbayItem_args()
6172 
    args.read(iprot)
6173 
    iprot.readMessageEnd()
6174 
    result = updateEbayItem_result()
6175 
    self._handler.updateEbayItem(args.ebayItem)
6176 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6177 
    result.write(oprot)
6178 
    oprot.writeMessageEnd()
6179 
    oprot.trans.flush()
6180 
 
8139 kshitij.so 6181 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6182 
    args = getAmazonListedItems_args()
6183 
    args.read(iprot)
6184 
    iprot.readMessageEnd()
6185 
    result = getAmazonListedItems_result()
6186 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6187 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6188 
    result.write(oprot)
6189 
    oprot.writeMessageEnd()
6190 
    oprot.trans.flush()
7977 kshitij.so 6191 
 
8168 kshitij.so 6192 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6193 
    args = updateAmazonAttributesInBulk_args()
6194 
    args.read(iprot)
6195 
    iprot.readMessageEnd()
6196 
    result = updateAmazonAttributesInBulk_result()
6197 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6198 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
8139 kshitij.so 6202 
 
8379 vikram.rag 6203 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6204 
    args = getAllItemstoListOnFba_args()
6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
6207 
    result = getAllItemstoListOnFba_result()
6208 
    result.success = self._handler.getAllItemstoListOnFba()
6209 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6210 
    result.write(oprot)
6211 
    oprot.writeMessageEnd()
6212 
    oprot.trans.flush()
8168 kshitij.so 6213 
 
8379 vikram.rag 6214 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6215 
    args = getAllItemstoListOnNonFba_args()
6216 
    args.read(iprot)
6217 
    iprot.readMessageEnd()
6218 
    result = getAllItemstoListOnNonFba_result()
6219 
    result.success = self._handler.getAllItemstoListOnNonFba()
6220 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6221 
    result.write(oprot)
6222 
    oprot.writeMessageEnd()
6223 
    oprot.trans.flush()
6224 
 
8616 vikram.rag 6225 
  def process_getAllSnapdealListedActiveItems(self, seqid, iprot, oprot):
6226 
    args = getAllSnapdealListedActiveItems_args()
6227 
    args.read(iprot)
6228 
    iprot.readMessageEnd()
6229 
    result = getAllSnapdealListedActiveItems_result()
6230 
    result.success = self._handler.getAllSnapdealListedActiveItems()
6231 
    oprot.writeMessageBegin("getAllSnapdealListedActiveItems", TMessageType.REPLY, seqid)
6232 
    result.write(oprot)
6233 
    oprot.writeMessageEnd()
6234 
    oprot.trans.flush()
8379 vikram.rag 6235 
 
8619 kshitij.so 6236 
  def process_updateAsin(self, seqid, iprot, oprot):
6237 
    args = updateAsin_args()
6238 
    args.read(iprot)
6239 
    iprot.readMessageEnd()
6240 
    result = updateAsin_result()
6241 
    self._handler.updateAsin(args.item)
6242 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6243 
    result.write(oprot)
6244 
    oprot.writeMessageEnd()
6245 
    oprot.trans.flush()
8616 vikram.rag 6246 
 
8619 kshitij.so 6247 
 
5944 mandeep.dh 6248 
# HELPER FUNCTIONS AND STRUCTURES
6249 
 
6250 
class addItem_args:
6251 
  """
6252 
  Attributes:
6253 
   - item
6254 
  """
6255 
 
6256 
  thrift_spec = (
6257 
    None, # 0
6258 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6259 
  )
6260 
 
6261 
  def __init__(self, item=None,):
6262 
    self.item = item
6263 
 
6264 
  def read(self, iprot):
6265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6267 
      return
6268 
    iprot.readStructBegin()
6269 
    while True:
6270 
      (fname, ftype, fid) = iprot.readFieldBegin()
6271 
      if ftype == TType.STOP:
6272 
        break
6273 
      if fid == 1:
6274 
        if ftype == TType.STRUCT:
6275 
          self.item = Item()
6276 
          self.item.read(iprot)
6277 
        else:
6278 
          iprot.skip(ftype)
6279 
      else:
6280 
        iprot.skip(ftype)
6281 
      iprot.readFieldEnd()
6282 
    iprot.readStructEnd()
6283 
 
6284 
  def write(self, oprot):
6285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6287 
      return
6288 
    oprot.writeStructBegin('addItem_args')
6289 
    if self.item is not None:
6290 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6291 
      self.item.write(oprot)
6292 
      oprot.writeFieldEnd()
6293 
    oprot.writeFieldStop()
6294 
    oprot.writeStructEnd()
6295 
 
6296 
  def validate(self):
6297 
    return
6298 
 
6299 
 
6300 
  def __repr__(self):
6301 
    L = ['%s=%r' % (key, value)
6302 
      for key, value in self.__dict__.iteritems()]
6303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6304 
 
6305 
  def __eq__(self, other):
6306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6307 
 
6308 
  def __ne__(self, other):
6309 
    return not (self == other)
6310 
 
6311 
class addItem_result:
6312 
  """
6313 
  Attributes:
6314 
   - success
6315 
   - cex
6316 
  """
6317 
 
6318 
  thrift_spec = (
6319 
    (0, TType.I64, 'success', None, None, ), # 0
6320 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6321 
  )
6322 
 
6323 
  def __init__(self, success=None, cex=None,):
6324 
    self.success = success
6325 
    self.cex = cex
6326 
 
6327 
  def read(self, iprot):
6328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6330 
      return
6331 
    iprot.readStructBegin()
6332 
    while True:
6333 
      (fname, ftype, fid) = iprot.readFieldBegin()
6334 
      if ftype == TType.STOP:
6335 
        break
6336 
      if fid == 0:
6337 
        if ftype == TType.I64:
6338 
          self.success = iprot.readI64();
6339 
        else:
6340 
          iprot.skip(ftype)
6341 
      elif fid == 1:
6342 
        if ftype == TType.STRUCT:
6343 
          self.cex = CatalogServiceException()
6344 
          self.cex.read(iprot)
6345 
        else:
6346 
          iprot.skip(ftype)
6347 
      else:
6348 
        iprot.skip(ftype)
6349 
      iprot.readFieldEnd()
6350 
    iprot.readStructEnd()
6351 
 
6352 
  def write(self, oprot):
6353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6355 
      return
6356 
    oprot.writeStructBegin('addItem_result')
6357 
    if self.success is not None:
6358 
      oprot.writeFieldBegin('success', TType.I64, 0)
6359 
      oprot.writeI64(self.success)
6360 
      oprot.writeFieldEnd()
6361 
    if self.cex is not None:
6362 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6363 
      self.cex.write(oprot)
6364 
      oprot.writeFieldEnd()
6365 
    oprot.writeFieldStop()
6366 
    oprot.writeStructEnd()
6367 
 
6368 
  def validate(self):
6369 
    return
6370 
 
6371 
 
6372 
  def __repr__(self):
6373 
    L = ['%s=%r' % (key, value)
6374 
      for key, value in self.__dict__.iteritems()]
6375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6376 
 
6377 
  def __eq__(self, other):
6378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6379 
 
6380 
  def __ne__(self, other):
6381 
    return not (self == other)
6382 
 
6383 
class updateItem_args:
6384 
  """
6385 
  Attributes:
6386 
   - item
6387 
  """
6388 
 
6389 
  thrift_spec = (
6390 
    None, # 0
6391 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6392 
  )
6393 
 
6394 
  def __init__(self, item=None,):
6395 
    self.item = item
6396 
 
6397 
  def read(self, iprot):
6398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6400 
      return
6401 
    iprot.readStructBegin()
6402 
    while True:
6403 
      (fname, ftype, fid) = iprot.readFieldBegin()
6404 
      if ftype == TType.STOP:
6405 
        break
6406 
      if fid == 1:
6407 
        if ftype == TType.STRUCT:
6408 
          self.item = Item()
6409 
          self.item.read(iprot)
6410 
        else:
6411 
          iprot.skip(ftype)
6412 
      else:
6413 
        iprot.skip(ftype)
6414 
      iprot.readFieldEnd()
6415 
    iprot.readStructEnd()
6416 
 
6417 
  def write(self, oprot):
6418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6420 
      return
6421 
    oprot.writeStructBegin('updateItem_args')
6422 
    if self.item is not None:
6423 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6424 
      self.item.write(oprot)
6425 
      oprot.writeFieldEnd()
6426 
    oprot.writeFieldStop()
6427 
    oprot.writeStructEnd()
6428 
 
6429 
  def validate(self):
6430 
    return
6431 
 
6432 
 
6433 
  def __repr__(self):
6434 
    L = ['%s=%r' % (key, value)
6435 
      for key, value in self.__dict__.iteritems()]
6436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6437 
 
6438 
  def __eq__(self, other):
6439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6440 
 
6441 
  def __ne__(self, other):
6442 
    return not (self == other)
6443 
 
6444 
class updateItem_result:
6445 
  """
6446 
  Attributes:
6447 
   - success
6448 
   - cex
6449 
  """
6450 
 
6451 
  thrift_spec = (
6452 
    (0, TType.I64, 'success', None, None, ), # 0
6453 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6454 
  )
6455 
 
6456 
  def __init__(self, success=None, cex=None,):
6457 
    self.success = success
6458 
    self.cex = cex
6459 
 
6460 
  def read(self, iprot):
6461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6463 
      return
6464 
    iprot.readStructBegin()
6465 
    while True:
6466 
      (fname, ftype, fid) = iprot.readFieldBegin()
6467 
      if ftype == TType.STOP:
6468 
        break
6469 
      if fid == 0:
6470 
        if ftype == TType.I64:
6471 
          self.success = iprot.readI64();
6472 
        else:
6473 
          iprot.skip(ftype)
6474 
      elif fid == 1:
6475 
        if ftype == TType.STRUCT:
6476 
          self.cex = CatalogServiceException()
6477 
          self.cex.read(iprot)
6478 
        else:
6479 
          iprot.skip(ftype)
6480 
      else:
6481 
        iprot.skip(ftype)
6482 
      iprot.readFieldEnd()
6483 
    iprot.readStructEnd()
6484 
 
6485 
  def write(self, oprot):
6486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6488 
      return
6489 
    oprot.writeStructBegin('updateItem_result')
6490 
    if self.success is not None:
6491 
      oprot.writeFieldBegin('success', TType.I64, 0)
6492 
      oprot.writeI64(self.success)
6493 
      oprot.writeFieldEnd()
6494 
    if self.cex is not None:
6495 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6496 
      self.cex.write(oprot)
6497 
      oprot.writeFieldEnd()
6498 
    oprot.writeFieldStop()
6499 
    oprot.writeStructEnd()
6500 
 
6501 
  def validate(self):
6502 
    return
6503 
 
6504 
 
6505 
  def __repr__(self):
6506 
    L = ['%s=%r' % (key, value)
6507 
      for key, value in self.__dict__.iteritems()]
6508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6509 
 
6510 
  def __eq__(self, other):
6511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6512 
 
6513 
  def __ne__(self, other):
6514 
    return not (self == other)
6515 
 
6516 
class isActive_args:
6517 
  """
6518 
  Attributes:
6519 
   - itemId
6520 
  """
6521 
 
6522 
  thrift_spec = (
6523 
    None, # 0
6524 
    (1, TType.I64, 'itemId', None, None, ), # 1
6525 
  )
6526 
 
6527 
  def __init__(self, itemId=None,):
6528 
    self.itemId = itemId
6529 
 
6530 
  def read(self, iprot):
6531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6533 
      return
6534 
    iprot.readStructBegin()
6535 
    while True:
6536 
      (fname, ftype, fid) = iprot.readFieldBegin()
6537 
      if ftype == TType.STOP:
6538 
        break
6539 
      if fid == 1:
6540 
        if ftype == TType.I64:
6541 
          self.itemId = iprot.readI64();
6542 
        else:
6543 
          iprot.skip(ftype)
6544 
      else:
6545 
        iprot.skip(ftype)
6546 
      iprot.readFieldEnd()
6547 
    iprot.readStructEnd()
6548 
 
6549 
  def write(self, oprot):
6550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6552 
      return
6553 
    oprot.writeStructBegin('isActive_args')
6554 
    if self.itemId is not None:
6555 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6556 
      oprot.writeI64(self.itemId)
6557 
      oprot.writeFieldEnd()
6558 
    oprot.writeFieldStop()
6559 
    oprot.writeStructEnd()
6560 
 
6561 
  def validate(self):
6562 
    return
6563 
 
6564 
 
6565 
  def __repr__(self):
6566 
    L = ['%s=%r' % (key, value)
6567 
      for key, value in self.__dict__.iteritems()]
6568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6569 
 
6570 
  def __eq__(self, other):
6571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6572 
 
6573 
  def __ne__(self, other):
6574 
    return not (self == other)
6575 
 
6576 
class isActive_result:
6577 
  """
6578 
  Attributes:
6579 
   - success
6580 
   - isex
6581 
  """
6582 
 
6583 
  thrift_spec = (
6584 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6585 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6586 
  )
6587 
 
6588 
  def __init__(self, success=None, isex=None,):
6589 
    self.success = success
6590 
    self.isex = isex
6591 
 
6592 
  def read(self, iprot):
6593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6595 
      return
6596 
    iprot.readStructBegin()
6597 
    while True:
6598 
      (fname, ftype, fid) = iprot.readFieldBegin()
6599 
      if ftype == TType.STOP:
6600 
        break
6601 
      if fid == 0:
6602 
        if ftype == TType.STRUCT:
6603 
          self.success = ItemShippingInfo()
6604 
          self.success.read(iprot)
6605 
        else:
6606 
          iprot.skip(ftype)
6607 
      elif fid == 1:
6608 
        if ftype == TType.STRUCT:
6609 
          self.isex = CatalogServiceException()
6610 
          self.isex.read(iprot)
6611 
        else:
6612 
          iprot.skip(ftype)
6613 
      else:
6614 
        iprot.skip(ftype)
6615 
      iprot.readFieldEnd()
6616 
    iprot.readStructEnd()
6617 
 
6618 
  def write(self, oprot):
6619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6621 
      return
6622 
    oprot.writeStructBegin('isActive_result')
6623 
    if self.success is not None:
6624 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6625 
      self.success.write(oprot)
6626 
      oprot.writeFieldEnd()
6627 
    if self.isex is not None:
6628 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6629 
      self.isex.write(oprot)
6630 
      oprot.writeFieldEnd()
6631 
    oprot.writeFieldStop()
6632 
    oprot.writeStructEnd()
6633 
 
6634 
  def validate(self):
6635 
    return
6636 
 
6637 
 
6638 
  def __repr__(self):
6639 
    L = ['%s=%r' % (key, value)
6640 
      for key, value in self.__dict__.iteritems()]
6641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6642 
 
6643 
  def __eq__(self, other):
6644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6645 
 
6646 
  def __ne__(self, other):
6647 
    return not (self == other)
6648 
 
7438 amit.gupta 6649 
class getItemsStatus_args:
6650 
  """
6651 
  Attributes:
6652 
   - itemIds
6653 
  """
6654 
 
6655 
  thrift_spec = (
6656 
    None, # 0
6657 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6658 
  )
6659 
 
6660 
  def __init__(self, itemIds=None,):
6661 
    self.itemIds = itemIds
6662 
 
6663 
  def read(self, iprot):
6664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6666 
      return
6667 
    iprot.readStructBegin()
6668 
    while True:
6669 
      (fname, ftype, fid) = iprot.readFieldBegin()
6670 
      if ftype == TType.STOP:
6671 
        break
6672 
      if fid == 1:
6673 
        if ftype == TType.LIST:
6674 
          self.itemIds = []
8590 kshitij.so 6675 
          (_etype33, _size30) = iprot.readListBegin()
6676 
          for _i34 in xrange(_size30):
6677 
            _elem35 = iprot.readI64();
6678 
            self.itemIds.append(_elem35)
7438 amit.gupta 6679 
          iprot.readListEnd()
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('getItemsStatus_args')
6692 
    if self.itemIds is not None:
6693 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6694 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 6695 
      for iter36 in self.itemIds:
6696 
        oprot.writeI64(iter36)
7438 amit.gupta 6697 
      oprot.writeListEnd()
6698 
      oprot.writeFieldEnd()
6699 
    oprot.writeFieldStop()
6700 
    oprot.writeStructEnd()
6701 
 
6702 
  def validate(self):
6703 
    return
6704 
 
6705 
 
6706 
  def __repr__(self):
6707 
    L = ['%s=%r' % (key, value)
6708 
      for key, value in self.__dict__.iteritems()]
6709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6710 
 
6711 
  def __eq__(self, other):
6712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6713 
 
6714 
  def __ne__(self, other):
6715 
    return not (self == other)
6716 
 
6717 
class getItemsStatus_result:
6718 
  """
6719 
  Attributes:
6720 
   - success
6721 
   - isex
6722 
  """
6723 
 
6724 
  thrift_spec = (
6725 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6726 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6727 
  )
6728 
 
6729 
  def __init__(self, success=None, isex=None,):
6730 
    self.success = success
6731 
    self.isex = isex
6732 
 
6733 
  def read(self, iprot):
6734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6736 
      return
6737 
    iprot.readStructBegin()
6738 
    while True:
6739 
      (fname, ftype, fid) = iprot.readFieldBegin()
6740 
      if ftype == TType.STOP:
6741 
        break
6742 
      if fid == 0:
6743 
        if ftype == TType.MAP:
6744 
          self.success = {}
8590 kshitij.so 6745 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
6746 
          for _i41 in xrange(_size37):
6747 
            _key42 = iprot.readI64();
6748 
            _val43 = iprot.readBool();
6749 
            self.success[_key42] = _val43
7438 amit.gupta 6750 
          iprot.readMapEnd()
6751 
        else:
6752 
          iprot.skip(ftype)
6753 
      elif fid == 1:
6754 
        if ftype == TType.STRUCT:
6755 
          self.isex = CatalogServiceException()
6756 
          self.isex.read(iprot)
6757 
        else:
6758 
          iprot.skip(ftype)
6759 
      else:
6760 
        iprot.skip(ftype)
6761 
      iprot.readFieldEnd()
6762 
    iprot.readStructEnd()
6763 
 
6764 
  def write(self, oprot):
6765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6767 
      return
6768 
    oprot.writeStructBegin('getItemsStatus_result')
6769 
    if self.success is not None:
6770 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6771 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 6772 
      for kiter44,viter45 in self.success.items():
6773 
        oprot.writeI64(kiter44)
6774 
        oprot.writeBool(viter45)
7438 amit.gupta 6775 
      oprot.writeMapEnd()
6776 
      oprot.writeFieldEnd()
6777 
    if self.isex is not None:
6778 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6779 
      self.isex.write(oprot)
6780 
      oprot.writeFieldEnd()
6781 
    oprot.writeFieldStop()
6782 
    oprot.writeStructEnd()
6783 
 
6784 
  def validate(self):
6785 
    return
6786 
 
6787 
 
6788 
  def __repr__(self):
6789 
    L = ['%s=%r' % (key, value)
6790 
      for key, value in self.__dict__.iteritems()]
6791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6792 
 
6793 
  def __eq__(self, other):
6794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6795 
 
6796 
  def __ne__(self, other):
6797 
    return not (self == other)
6798 
 
5944 mandeep.dh 6799 
class getItemStatusDescription_args:
6800 
  """
6801 
  Attributes:
6802 
   - itemId
6803 
  """
6804 
 
6805 
  thrift_spec = (
6806 
    None, # 0
6807 
    (1, TType.I64, 'itemId', None, None, ), # 1
6808 
  )
6809 
 
6810 
  def __init__(self, itemId=None,):
6811 
    self.itemId = itemId
6812 
 
6813 
  def read(self, iprot):
6814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6816 
      return
6817 
    iprot.readStructBegin()
6818 
    while True:
6819 
      (fname, ftype, fid) = iprot.readFieldBegin()
6820 
      if ftype == TType.STOP:
6821 
        break
6822 
      if fid == 1:
6823 
        if ftype == TType.I64:
6824 
          self.itemId = iprot.readI64();
6825 
        else:
6826 
          iprot.skip(ftype)
6827 
      else:
6828 
        iprot.skip(ftype)
6829 
      iprot.readFieldEnd()
6830 
    iprot.readStructEnd()
6831 
 
6832 
  def write(self, oprot):
6833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6835 
      return
6836 
    oprot.writeStructBegin('getItemStatusDescription_args')
6837 
    if self.itemId is not None:
6838 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6839 
      oprot.writeI64(self.itemId)
6840 
      oprot.writeFieldEnd()
6841 
    oprot.writeFieldStop()
6842 
    oprot.writeStructEnd()
6843 
 
6844 
  def validate(self):
6845 
    return
6846 
 
6847 
 
6848 
  def __repr__(self):
6849 
    L = ['%s=%r' % (key, value)
6850 
      for key, value in self.__dict__.iteritems()]
6851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6852 
 
6853 
  def __eq__(self, other):
6854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6855 
 
6856 
  def __ne__(self, other):
6857 
    return not (self == other)
6858 
 
6859 
class getItemStatusDescription_result:
6860 
  """
6861 
  Attributes:
6862 
   - success
6863 
   - isex
6864 
  """
6865 
 
6866 
  thrift_spec = (
6867 
    (0, TType.STRING, 'success', None, None, ), # 0
6868 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6869 
  )
6870 
 
6871 
  def __init__(self, success=None, isex=None,):
6872 
    self.success = success
6873 
    self.isex = isex
6874 
 
6875 
  def read(self, iprot):
6876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6878 
      return
6879 
    iprot.readStructBegin()
6880 
    while True:
6881 
      (fname, ftype, fid) = iprot.readFieldBegin()
6882 
      if ftype == TType.STOP:
6883 
        break
6884 
      if fid == 0:
6885 
        if ftype == TType.STRING:
6886 
          self.success = iprot.readString();
6887 
        else:
6888 
          iprot.skip(ftype)
6889 
      elif fid == 1:
6890 
        if ftype == TType.STRUCT:
6891 
          self.isex = CatalogServiceException()
6892 
          self.isex.read(iprot)
6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      else:
6896 
        iprot.skip(ftype)
6897 
      iprot.readFieldEnd()
6898 
    iprot.readStructEnd()
6899 
 
6900 
  def write(self, oprot):
6901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6903 
      return
6904 
    oprot.writeStructBegin('getItemStatusDescription_result')
6905 
    if self.success is not None:
6906 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6907 
      oprot.writeString(self.success)
6908 
      oprot.writeFieldEnd()
6909 
    if self.isex is not None:
6910 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6911 
      self.isex.write(oprot)
6912 
      oprot.writeFieldEnd()
6913 
    oprot.writeFieldStop()
6914 
    oprot.writeStructEnd()
6915 
 
6916 
  def validate(self):
6917 
    return
6918 
 
6919 
 
6920 
  def __repr__(self):
6921 
    L = ['%s=%r' % (key, value)
6922 
      for key, value in self.__dict__.iteritems()]
6923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6924 
 
6925 
  def __eq__(self, other):
6926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6927 
 
6928 
  def __ne__(self, other):
6929 
    return not (self == other)
6930 
 
6931 
class startItemOn_args:
6932 
  """
6933 
  Attributes:
6934 
   - item_id
6935 
   - timestamp
6936 
  """
6937 
 
6938 
  thrift_spec = (
6939 
    None, # 0
6940 
    (1, TType.I64, 'item_id', None, None, ), # 1
6941 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6942 
  )
6943 
 
6944 
  def __init__(self, item_id=None, timestamp=None,):
6945 
    self.item_id = item_id
6946 
    self.timestamp = timestamp
6947 
 
6948 
  def read(self, iprot):
6949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6951 
      return
6952 
    iprot.readStructBegin()
6953 
    while True:
6954 
      (fname, ftype, fid) = iprot.readFieldBegin()
6955 
      if ftype == TType.STOP:
6956 
        break
6957 
      if fid == 1:
6958 
        if ftype == TType.I64:
6959 
          self.item_id = iprot.readI64();
6960 
        else:
6961 
          iprot.skip(ftype)
6962 
      elif fid == 2:
6963 
        if ftype == TType.I64:
6964 
          self.timestamp = iprot.readI64();
6965 
        else:
6966 
          iprot.skip(ftype)
6967 
      else:
6968 
        iprot.skip(ftype)
6969 
      iprot.readFieldEnd()
6970 
    iprot.readStructEnd()
6971 
 
6972 
  def write(self, oprot):
6973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6975 
      return
6976 
    oprot.writeStructBegin('startItemOn_args')
6977 
    if self.item_id is not None:
6978 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6979 
      oprot.writeI64(self.item_id)
6980 
      oprot.writeFieldEnd()
6981 
    if self.timestamp is not None:
6982 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6983 
      oprot.writeI64(self.timestamp)
6984 
      oprot.writeFieldEnd()
6985 
    oprot.writeFieldStop()
6986 
    oprot.writeStructEnd()
6987 
 
6988 
  def validate(self):
6989 
    return
6990 
 
6991 
 
6992 
  def __repr__(self):
6993 
    L = ['%s=%r' % (key, value)
6994 
      for key, value in self.__dict__.iteritems()]
6995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6996 
 
6997 
  def __eq__(self, other):
6998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6999 
 
7000 
  def __ne__(self, other):
7001 
    return not (self == other)
7002 
 
7003 
class startItemOn_result:
7004 
  """
7005 
  Attributes:
7006 
   - cex
7007 
  """
7008 
 
7009 
  thrift_spec = (
7010 
    None, # 0
7011 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7012 
  )
7013 
 
7014 
  def __init__(self, cex=None,):
7015 
    self.cex = cex
7016 
 
7017 
  def read(self, iprot):
7018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7020 
      return
7021 
    iprot.readStructBegin()
7022 
    while True:
7023 
      (fname, ftype, fid) = iprot.readFieldBegin()
7024 
      if ftype == TType.STOP:
7025 
        break
7026 
      if fid == 1:
7027 
        if ftype == TType.STRUCT:
7028 
          self.cex = CatalogServiceException()
7029 
          self.cex.read(iprot)
7030 
        else:
7031 
          iprot.skip(ftype)
7032 
      else:
7033 
        iprot.skip(ftype)
7034 
      iprot.readFieldEnd()
7035 
    iprot.readStructEnd()
7036 
 
7037 
  def write(self, oprot):
7038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7040 
      return
7041 
    oprot.writeStructBegin('startItemOn_result')
7042 
    if self.cex is not None:
7043 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7044 
      self.cex.write(oprot)
7045 
      oprot.writeFieldEnd()
7046 
    oprot.writeFieldStop()
7047 
    oprot.writeStructEnd()
7048 
 
7049 
  def validate(self):
7050 
    return
7051 
 
7052 
 
7053 
  def __repr__(self):
7054 
    L = ['%s=%r' % (key, value)
7055 
      for key, value in self.__dict__.iteritems()]
7056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7057 
 
7058 
  def __eq__(self, other):
7059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7060 
 
7061 
  def __ne__(self, other):
7062 
    return not (self == other)
7063 
 
7064 
class retireItemOn_args:
7065 
  """
7066 
  Attributes:
7067 
   - item_id
7068 
   - timestamp
7069 
  """
7070 
 
7071 
  thrift_spec = (
7072 
    None, # 0
7073 
    (1, TType.I64, 'item_id', None, None, ), # 1
7074 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7075 
  )
7076 
 
7077 
  def __init__(self, item_id=None, timestamp=None,):
7078 
    self.item_id = item_id
7079 
    self.timestamp = timestamp
7080 
 
7081 
  def read(self, iprot):
7082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7084 
      return
7085 
    iprot.readStructBegin()
7086 
    while True:
7087 
      (fname, ftype, fid) = iprot.readFieldBegin()
7088 
      if ftype == TType.STOP:
7089 
        break
7090 
      if fid == 1:
7091 
        if ftype == TType.I64:
7092 
          self.item_id = iprot.readI64();
7093 
        else:
7094 
          iprot.skip(ftype)
7095 
      elif fid == 2:
7096 
        if ftype == TType.I64:
7097 
          self.timestamp = iprot.readI64();
7098 
        else:
7099 
          iprot.skip(ftype)
7100 
      else:
7101 
        iprot.skip(ftype)
7102 
      iprot.readFieldEnd()
7103 
    iprot.readStructEnd()
7104 
 
7105 
  def write(self, oprot):
7106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7108 
      return
7109 
    oprot.writeStructBegin('retireItemOn_args')
7110 
    if self.item_id is not None:
7111 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7112 
      oprot.writeI64(self.item_id)
7113 
      oprot.writeFieldEnd()
7114 
    if self.timestamp is not None:
7115 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7116 
      oprot.writeI64(self.timestamp)
7117 
      oprot.writeFieldEnd()
7118 
    oprot.writeFieldStop()
7119 
    oprot.writeStructEnd()
7120 
 
7121 
  def validate(self):
7122 
    return
7123 
 
7124 
 
7125 
  def __repr__(self):
7126 
    L = ['%s=%r' % (key, value)
7127 
      for key, value in self.__dict__.iteritems()]
7128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7129 
 
7130 
  def __eq__(self, other):
7131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7132 
 
7133 
  def __ne__(self, other):
7134 
    return not (self == other)
7135 
 
7136 
class retireItemOn_result:
7137 
  """
7138 
  Attributes:
7139 
   - cex
7140 
  """
7141 
 
7142 
  thrift_spec = (
7143 
    None, # 0
7144 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7145 
  )
7146 
 
7147 
  def __init__(self, cex=None,):
7148 
    self.cex = cex
7149 
 
7150 
  def read(self, iprot):
7151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7153 
      return
7154 
    iprot.readStructBegin()
7155 
    while True:
7156 
      (fname, ftype, fid) = iprot.readFieldBegin()
7157 
      if ftype == TType.STOP:
7158 
        break
7159 
      if fid == 1:
7160 
        if ftype == TType.STRUCT:
7161 
          self.cex = CatalogServiceException()
7162 
          self.cex.read(iprot)
7163 
        else:
7164 
          iprot.skip(ftype)
7165 
      else:
7166 
        iprot.skip(ftype)
7167 
      iprot.readFieldEnd()
7168 
    iprot.readStructEnd()
7169 
 
7170 
  def write(self, oprot):
7171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7173 
      return
7174 
    oprot.writeStructBegin('retireItemOn_result')
7175 
    if self.cex is not None:
7176 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7177 
      self.cex.write(oprot)
7178 
      oprot.writeFieldEnd()
7179 
    oprot.writeFieldStop()
7180 
    oprot.writeStructEnd()
7181 
 
7182 
  def validate(self):
7183 
    return
7184 
 
7185 
 
7186 
  def __repr__(self):
7187 
    L = ['%s=%r' % (key, value)
7188 
      for key, value in self.__dict__.iteritems()]
7189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7190 
 
7191 
  def __eq__(self, other):
7192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7193 
 
7194 
  def __ne__(self, other):
7195 
    return not (self == other)
7196 
 
7197 
class changeItemStatus_args:
7198 
  """
7199 
  Attributes:
7200 
   - item_id
7201 
   - timestamp
7202 
   - newstatus
7203 
  """
7204 
 
7205 
  thrift_spec = (
7206 
    None, # 0
7207 
    (1, TType.I64, 'item_id', None, None, ), # 1
7208 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7209 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7210 
  )
7211 
 
7212 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7213 
    self.item_id = item_id
7214 
    self.timestamp = timestamp
7215 
    self.newstatus = newstatus
7216 
 
7217 
  def read(self, iprot):
7218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7220 
      return
7221 
    iprot.readStructBegin()
7222 
    while True:
7223 
      (fname, ftype, fid) = iprot.readFieldBegin()
7224 
      if ftype == TType.STOP:
7225 
        break
7226 
      if fid == 1:
7227 
        if ftype == TType.I64:
7228 
          self.item_id = iprot.readI64();
7229 
        else:
7230 
          iprot.skip(ftype)
7231 
      elif fid == 2:
7232 
        if ftype == TType.I64:
7233 
          self.timestamp = iprot.readI64();
7234 
        else:
7235 
          iprot.skip(ftype)
7236 
      elif fid == 3:
7237 
        if ftype == TType.I32:
7238 
          self.newstatus = iprot.readI32();
7239 
        else:
7240 
          iprot.skip(ftype)
7241 
      else:
7242 
        iprot.skip(ftype)
7243 
      iprot.readFieldEnd()
7244 
    iprot.readStructEnd()
7245 
 
7246 
  def write(self, oprot):
7247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7249 
      return
7250 
    oprot.writeStructBegin('changeItemStatus_args')
7251 
    if self.item_id is not None:
7252 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7253 
      oprot.writeI64(self.item_id)
7254 
      oprot.writeFieldEnd()
7255 
    if self.timestamp is not None:
7256 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7257 
      oprot.writeI64(self.timestamp)
7258 
      oprot.writeFieldEnd()
7259 
    if self.newstatus is not None:
7260 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7261 
      oprot.writeI32(self.newstatus)
7262 
      oprot.writeFieldEnd()
7263 
    oprot.writeFieldStop()
7264 
    oprot.writeStructEnd()
7265 
 
7266 
  def validate(self):
7267 
    return
7268 
 
7269 
 
7270 
  def __repr__(self):
7271 
    L = ['%s=%r' % (key, value)
7272 
      for key, value in self.__dict__.iteritems()]
7273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7274 
 
7275 
  def __eq__(self, other):
7276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7277 
 
7278 
  def __ne__(self, other):
7279 
    return not (self == other)
7280 
 
7281 
class changeItemStatus_result:
7282 
  """
7283 
  Attributes:
7284 
   - cex
7285 
  """
7286 
 
7287 
  thrift_spec = (
7288 
    None, # 0
7289 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7290 
  )
7291 
 
7292 
  def __init__(self, cex=None,):
7293 
    self.cex = cex
7294 
 
7295 
  def read(self, iprot):
7296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7298 
      return
7299 
    iprot.readStructBegin()
7300 
    while True:
7301 
      (fname, ftype, fid) = iprot.readFieldBegin()
7302 
      if ftype == TType.STOP:
7303 
        break
7304 
      if fid == 1:
7305 
        if ftype == TType.STRUCT:
7306 
          self.cex = CatalogServiceException()
7307 
          self.cex.read(iprot)
7308 
        else:
7309 
          iprot.skip(ftype)
7310 
      else:
7311 
        iprot.skip(ftype)
7312 
      iprot.readFieldEnd()
7313 
    iprot.readStructEnd()
7314 
 
7315 
  def write(self, oprot):
7316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7318 
      return
7319 
    oprot.writeStructBegin('changeItemStatus_result')
7320 
    if self.cex is not None:
7321 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7322 
      self.cex.write(oprot)
7323 
      oprot.writeFieldEnd()
7324 
    oprot.writeFieldStop()
7325 
    oprot.writeStructEnd()
7326 
 
7327 
  def validate(self):
7328 
    return
7329 
 
7330 
 
7331 
  def __repr__(self):
7332 
    L = ['%s=%r' % (key, value)
7333 
      for key, value in self.__dict__.iteritems()]
7334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7335 
 
7336 
  def __eq__(self, other):
7337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7338 
 
7339 
  def __ne__(self, other):
7340 
    return not (self == other)
7341 
 
7342 
class getItem_args:
7343 
  """
7344 
  Attributes:
7345 
   - item_id
7346 
  """
7347 
 
7348 
  thrift_spec = (
7349 
    None, # 0
7350 
    (1, TType.I64, 'item_id', None, None, ), # 1
7351 
  )
7352 
 
7353 
  def __init__(self, item_id=None,):
7354 
    self.item_id = item_id
7355 
 
7356 
  def read(self, iprot):
7357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7359 
      return
7360 
    iprot.readStructBegin()
7361 
    while True:
7362 
      (fname, ftype, fid) = iprot.readFieldBegin()
7363 
      if ftype == TType.STOP:
7364 
        break
7365 
      if fid == 1:
7366 
        if ftype == TType.I64:
7367 
          self.item_id = iprot.readI64();
7368 
        else:
7369 
          iprot.skip(ftype)
7370 
      else:
7371 
        iprot.skip(ftype)
7372 
      iprot.readFieldEnd()
7373 
    iprot.readStructEnd()
7374 
 
7375 
  def write(self, oprot):
7376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7378 
      return
7379 
    oprot.writeStructBegin('getItem_args')
7380 
    if self.item_id is not None:
7381 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7382 
      oprot.writeI64(self.item_id)
7383 
      oprot.writeFieldEnd()
7384 
    oprot.writeFieldStop()
7385 
    oprot.writeStructEnd()
7386 
 
7387 
  def validate(self):
7388 
    return
7389 
 
7390 
 
7391 
  def __repr__(self):
7392 
    L = ['%s=%r' % (key, value)
7393 
      for key, value in self.__dict__.iteritems()]
7394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7395 
 
7396 
  def __eq__(self, other):
7397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7398 
 
7399 
  def __ne__(self, other):
7400 
    return not (self == other)
7401 
 
7402 
class getItem_result:
7403 
  """
7404 
  Attributes:
7405 
   - success
7406 
   - cex
7407 
  """
7408 
 
7409 
  thrift_spec = (
7410 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7411 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7412 
  )
7413 
 
7414 
  def __init__(self, success=None, cex=None,):
7415 
    self.success = success
7416 
    self.cex = cex
7417 
 
7418 
  def read(self, iprot):
7419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7421 
      return
7422 
    iprot.readStructBegin()
7423 
    while True:
7424 
      (fname, ftype, fid) = iprot.readFieldBegin()
7425 
      if ftype == TType.STOP:
7426 
        break
7427 
      if fid == 0:
7428 
        if ftype == TType.STRUCT:
7429 
          self.success = Item()
7430 
          self.success.read(iprot)
7431 
        else:
7432 
          iprot.skip(ftype)
7433 
      elif fid == 1:
7434 
        if ftype == TType.STRUCT:
7435 
          self.cex = CatalogServiceException()
7436 
          self.cex.read(iprot)
7437 
        else:
7438 
          iprot.skip(ftype)
7439 
      else:
7440 
        iprot.skip(ftype)
7441 
      iprot.readFieldEnd()
7442 
    iprot.readStructEnd()
7443 
 
7444 
  def write(self, oprot):
7445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7447 
      return
7448 
    oprot.writeStructBegin('getItem_result')
7449 
    if self.success is not None:
7450 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7451 
      self.success.write(oprot)
7452 
      oprot.writeFieldEnd()
7453 
    if self.cex is not None:
7454 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7455 
      self.cex.write(oprot)
7456 
      oprot.writeFieldEnd()
7457 
    oprot.writeFieldStop()
7458 
    oprot.writeStructEnd()
7459 
 
7460 
  def validate(self):
7461 
    return
7462 
 
7463 
 
7464 
  def __repr__(self):
7465 
    L = ['%s=%r' % (key, value)
7466 
      for key, value in self.__dict__.iteritems()]
7467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7468 
 
7469 
  def __eq__(self, other):
7470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7471 
 
7472 
  def __ne__(self, other):
7473 
    return not (self == other)
7474 
 
7475 
class getItemsByCatalogId_args:
7476 
  """
7477 
  Attributes:
7478 
   - catalog_item_id
7479 
  """
7480 
 
7481 
  thrift_spec = (
7482 
    None, # 0
7483 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7484 
  )
7485 
 
7486 
  def __init__(self, catalog_item_id=None,):
7487 
    self.catalog_item_id = catalog_item_id
7488 
 
7489 
  def read(self, iprot):
7490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7492 
      return
7493 
    iprot.readStructBegin()
7494 
    while True:
7495 
      (fname, ftype, fid) = iprot.readFieldBegin()
7496 
      if ftype == TType.STOP:
7497 
        break
7498 
      if fid == 1:
7499 
        if ftype == TType.I64:
7500 
          self.catalog_item_id = iprot.readI64();
7501 
        else:
7502 
          iprot.skip(ftype)
7503 
      else:
7504 
        iprot.skip(ftype)
7505 
      iprot.readFieldEnd()
7506 
    iprot.readStructEnd()
7507 
 
7508 
  def write(self, oprot):
7509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7511 
      return
7512 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7513 
    if self.catalog_item_id is not None:
7514 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7515 
      oprot.writeI64(self.catalog_item_id)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
7520 
  def validate(self):
7521 
    return
7522 
 
7523 
 
7524 
  def __repr__(self):
7525 
    L = ['%s=%r' % (key, value)
7526 
      for key, value in self.__dict__.iteritems()]
7527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7528 
 
7529 
  def __eq__(self, other):
7530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7531 
 
7532 
  def __ne__(self, other):
7533 
    return not (self == other)
7534 
 
7535 
class getItemsByCatalogId_result:
7536 
  """
7537 
  Attributes:
7538 
   - success
7539 
   - cex
7540 
  """
7541 
 
7542 
  thrift_spec = (
7543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7544 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7545 
  )
7546 
 
7547 
  def __init__(self, success=None, cex=None,):
7548 
    self.success = success
7549 
    self.cex = cex
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      if fid == 0:
7561 
        if ftype == TType.LIST:
7562 
          self.success = []
8590 kshitij.so 7563 
          (_etype49, _size46) = iprot.readListBegin()
7564 
          for _i50 in xrange(_size46):
7565 
            _elem51 = Item()
7566 
            _elem51.read(iprot)
7567 
            self.success.append(_elem51)
5944 mandeep.dh 7568 
          iprot.readListEnd()
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('getItemsByCatalogId_result')
7587 
    if self.success is not None:
7588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7590 
      for iter52 in self.success:
7591 
        iter52.write(oprot)
5944 mandeep.dh 7592 
      oprot.writeListEnd()
7593 
      oprot.writeFieldEnd()
7594 
    if self.cex is not None:
7595 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7596 
      self.cex.write(oprot)
7597 
      oprot.writeFieldEnd()
7598 
    oprot.writeFieldStop()
7599 
    oprot.writeStructEnd()
7600 
 
7601 
  def validate(self):
7602 
    return
7603 
 
7604 
 
7605 
  def __repr__(self):
7606 
    L = ['%s=%r' % (key, value)
7607 
      for key, value in self.__dict__.iteritems()]
7608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7609 
 
7610 
  def __eq__(self, other):
7611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7612 
 
7613 
  def __ne__(self, other):
7614 
    return not (self == other)
7615 
 
7616 
class getValidItemsByCatalogId_args:
7617 
  """
7618 
  Attributes:
7619 
   - catalog_item_id
7620 
  """
7621 
 
7622 
  thrift_spec = (
7623 
    None, # 0
7624 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7625 
  )
7626 
 
7627 
  def __init__(self, catalog_item_id=None,):
7628 
    self.catalog_item_id = catalog_item_id
7629 
 
7630 
  def read(self, iprot):
7631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7633 
      return
7634 
    iprot.readStructBegin()
7635 
    while True:
7636 
      (fname, ftype, fid) = iprot.readFieldBegin()
7637 
      if ftype == TType.STOP:
7638 
        break
7639 
      if fid == 1:
7640 
        if ftype == TType.I64:
7641 
          self.catalog_item_id = iprot.readI64();
7642 
        else:
7643 
          iprot.skip(ftype)
7644 
      else:
7645 
        iprot.skip(ftype)
7646 
      iprot.readFieldEnd()
7647 
    iprot.readStructEnd()
7648 
 
7649 
  def write(self, oprot):
7650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7652 
      return
7653 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7654 
    if self.catalog_item_id is not None:
7655 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7656 
      oprot.writeI64(self.catalog_item_id)
7657 
      oprot.writeFieldEnd()
7658 
    oprot.writeFieldStop()
7659 
    oprot.writeStructEnd()
7660 
 
7661 
  def validate(self):
7662 
    return
7663 
 
7664 
 
7665 
  def __repr__(self):
7666 
    L = ['%s=%r' % (key, value)
7667 
      for key, value in self.__dict__.iteritems()]
7668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7669 
 
7670 
  def __eq__(self, other):
7671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7672 
 
7673 
  def __ne__(self, other):
7674 
    return not (self == other)
7675 
 
7676 
class getValidItemsByCatalogId_result:
7677 
  """
7678 
  Attributes:
7679 
   - success
7680 
   - cex
7681 
  """
7682 
 
7683 
  thrift_spec = (
7684 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7685 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7686 
  )
7687 
 
7688 
  def __init__(self, success=None, cex=None,):
7689 
    self.success = success
7690 
    self.cex = cex
7691 
 
7692 
  def read(self, iprot):
7693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7695 
      return
7696 
    iprot.readStructBegin()
7697 
    while True:
7698 
      (fname, ftype, fid) = iprot.readFieldBegin()
7699 
      if ftype == TType.STOP:
7700 
        break
7701 
      if fid == 0:
7702 
        if ftype == TType.LIST:
7703 
          self.success = []
8590 kshitij.so 7704 
          (_etype56, _size53) = iprot.readListBegin()
7705 
          for _i57 in xrange(_size53):
7706 
            _elem58 = Item()
7707 
            _elem58.read(iprot)
7708 
            self.success.append(_elem58)
5944 mandeep.dh 7709 
          iprot.readListEnd()
7710 
        else:
7711 
          iprot.skip(ftype)
7712 
      elif fid == 1:
7713 
        if ftype == TType.STRUCT:
7714 
          self.cex = CatalogServiceException()
7715 
          self.cex.read(iprot)
7716 
        else:
7717 
          iprot.skip(ftype)
7718 
      else:
7719 
        iprot.skip(ftype)
7720 
      iprot.readFieldEnd()
7721 
    iprot.readStructEnd()
7722 
 
7723 
  def write(self, oprot):
7724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7726 
      return
7727 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7728 
    if self.success is not None:
7729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7731 
      for iter59 in self.success:
7732 
        iter59.write(oprot)
5944 mandeep.dh 7733 
      oprot.writeListEnd()
7734 
      oprot.writeFieldEnd()
7735 
    if self.cex is not None:
7736 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7737 
      self.cex.write(oprot)
7738 
      oprot.writeFieldEnd()
7739 
    oprot.writeFieldStop()
7740 
    oprot.writeStructEnd()
7741 
 
7742 
  def validate(self):
7743 
    return
7744 
 
7745 
 
7746 
  def __repr__(self):
7747 
    L = ['%s=%r' % (key, value)
7748 
      for key, value in self.__dict__.iteritems()]
7749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7750 
 
7751 
  def __eq__(self, other):
7752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7753 
 
7754 
  def __ne__(self, other):
7755 
    return not (self == other)
7756 
 
7757 
class getAllItems_args:
7758 
  """
7759 
  Attributes:
7760 
   - isActive
7761 
  """
7762 
 
7763 
  thrift_spec = (
7764 
    None, # 0
7765 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7766 
  )
7767 
 
7768 
  def __init__(self, isActive=None,):
7769 
    self.isActive = isActive
7770 
 
7771 
  def read(self, iprot):
7772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7774 
      return
7775 
    iprot.readStructBegin()
7776 
    while True:
7777 
      (fname, ftype, fid) = iprot.readFieldBegin()
7778 
      if ftype == TType.STOP:
7779 
        break
7780 
      if fid == 1:
7781 
        if ftype == TType.BOOL:
7782 
          self.isActive = iprot.readBool();
7783 
        else:
7784 
          iprot.skip(ftype)
7785 
      else:
7786 
        iprot.skip(ftype)
7787 
      iprot.readFieldEnd()
7788 
    iprot.readStructEnd()
7789 
 
7790 
  def write(self, oprot):
7791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7793 
      return
7794 
    oprot.writeStructBegin('getAllItems_args')
7795 
    if self.isActive is not None:
7796 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7797 
      oprot.writeBool(self.isActive)
7798 
      oprot.writeFieldEnd()
7799 
    oprot.writeFieldStop()
7800 
    oprot.writeStructEnd()
7801 
 
7802 
  def validate(self):
7803 
    return
7804 
 
7805 
 
7806 
  def __repr__(self):
7807 
    L = ['%s=%r' % (key, value)
7808 
      for key, value in self.__dict__.iteritems()]
7809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7810 
 
7811 
  def __eq__(self, other):
7812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7813 
 
7814 
  def __ne__(self, other):
7815 
    return not (self == other)
7816 
 
7817 
class getAllItems_result:
7818 
  """
7819 
  Attributes:
7820 
   - success
7821 
   - cex
7822 
  """
7823 
 
7824 
  thrift_spec = (
7825 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7826 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7827 
  )
7828 
 
7829 
  def __init__(self, success=None, cex=None,):
7830 
    self.success = success
7831 
    self.cex = cex
7832 
 
7833 
  def read(self, iprot):
7834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7836 
      return
7837 
    iprot.readStructBegin()
7838 
    while True:
7839 
      (fname, ftype, fid) = iprot.readFieldBegin()
7840 
      if ftype == TType.STOP:
7841 
        break
7842 
      if fid == 0:
7843 
        if ftype == TType.LIST:
7844 
          self.success = []
8590 kshitij.so 7845 
          (_etype63, _size60) = iprot.readListBegin()
7846 
          for _i64 in xrange(_size60):
7847 
            _elem65 = Item()
7848 
            _elem65.read(iprot)
7849 
            self.success.append(_elem65)
5944 mandeep.dh 7850 
          iprot.readListEnd()
7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      elif fid == 1:
7854 
        if ftype == TType.STRUCT:
7855 
          self.cex = CatalogServiceException()
7856 
          self.cex.read(iprot)
7857 
        else:
7858 
          iprot.skip(ftype)
7859 
      else:
7860 
        iprot.skip(ftype)
7861 
      iprot.readFieldEnd()
7862 
    iprot.readStructEnd()
7863 
 
7864 
  def write(self, oprot):
7865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7867 
      return
7868 
    oprot.writeStructBegin('getAllItems_result')
7869 
    if self.success is not None:
7870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7872 
      for iter66 in self.success:
7873 
        iter66.write(oprot)
5944 mandeep.dh 7874 
      oprot.writeListEnd()
7875 
      oprot.writeFieldEnd()
7876 
    if self.cex is not None:
7877 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7878 
      self.cex.write(oprot)
7879 
      oprot.writeFieldEnd()
7880 
    oprot.writeFieldStop()
7881 
    oprot.writeStructEnd()
7882 
 
7883 
  def validate(self):
7884 
    return
7885 
 
7886 
 
7887 
  def __repr__(self):
7888 
    L = ['%s=%r' % (key, value)
7889 
      for key, value in self.__dict__.iteritems()]
7890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7891 
 
7892 
  def __eq__(self, other):
7893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7894 
 
7895 
  def __ne__(self, other):
7896 
    return not (self == other)
7897 
 
7898 
class getAllItemsByStatus_args:
7899 
  """
7900 
  Attributes:
7901 
   - itemStatus
7902 
  """
7903 
 
7904 
  thrift_spec = (
7905 
    None, # 0
7906 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7907 
  )
7908 
 
7909 
  def __init__(self, itemStatus=None,):
7910 
    self.itemStatus = itemStatus
7911 
 
7912 
  def read(self, iprot):
7913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7915 
      return
7916 
    iprot.readStructBegin()
7917 
    while True:
7918 
      (fname, ftype, fid) = iprot.readFieldBegin()
7919 
      if ftype == TType.STOP:
7920 
        break
7921 
      if fid == 1:
7922 
        if ftype == TType.I32:
7923 
          self.itemStatus = iprot.readI32();
7924 
        else:
7925 
          iprot.skip(ftype)
7926 
      else:
7927 
        iprot.skip(ftype)
7928 
      iprot.readFieldEnd()
7929 
    iprot.readStructEnd()
7930 
 
7931 
  def write(self, oprot):
7932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7934 
      return
7935 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7936 
    if self.itemStatus is not None:
7937 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7938 
      oprot.writeI32(self.itemStatus)
7939 
      oprot.writeFieldEnd()
7940 
    oprot.writeFieldStop()
7941 
    oprot.writeStructEnd()
7942 
 
7943 
  def validate(self):
7944 
    return
7945 
 
7946 
 
7947 
  def __repr__(self):
7948 
    L = ['%s=%r' % (key, value)
7949 
      for key, value in self.__dict__.iteritems()]
7950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7951 
 
7952 
  def __eq__(self, other):
7953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7954 
 
7955 
  def __ne__(self, other):
7956 
    return not (self == other)
7957 
 
7958 
class getAllItemsByStatus_result:
7959 
  """
7960 
  Attributes:
7961 
   - success
7962 
   - cex
7963 
  """
7964 
 
7965 
  thrift_spec = (
7966 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7967 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7968 
  )
7969 
 
7970 
  def __init__(self, success=None, cex=None,):
7971 
    self.success = success
7972 
    self.cex = cex
7973 
 
7974 
  def read(self, iprot):
7975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7977 
      return
7978 
    iprot.readStructBegin()
7979 
    while True:
7980 
      (fname, ftype, fid) = iprot.readFieldBegin()
7981 
      if ftype == TType.STOP:
7982 
        break
7983 
      if fid == 0:
7984 
        if ftype == TType.LIST:
7985 
          self.success = []
8590 kshitij.so 7986 
          (_etype70, _size67) = iprot.readListBegin()
7987 
          for _i71 in xrange(_size67):
7988 
            _elem72 = Item()
7989 
            _elem72.read(iprot)
7990 
            self.success.append(_elem72)
5944 mandeep.dh 7991 
          iprot.readListEnd()
7992 
        else:
7993 
          iprot.skip(ftype)
7994 
      elif fid == 1:
7995 
        if ftype == TType.STRUCT:
7996 
          self.cex = CatalogServiceException()
7997 
          self.cex.read(iprot)
7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      else:
8001 
        iprot.skip(ftype)
8002 
      iprot.readFieldEnd()
8003 
    iprot.readStructEnd()
8004 
 
8005 
  def write(self, oprot):
8006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8008 
      return
8009 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8010 
    if self.success is not None:
8011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8012 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8013 
      for iter73 in self.success:
8014 
        iter73.write(oprot)
5944 mandeep.dh 8015 
      oprot.writeListEnd()
8016 
      oprot.writeFieldEnd()
8017 
    if self.cex is not None:
8018 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8019 
      self.cex.write(oprot)
8020 
      oprot.writeFieldEnd()
8021 
    oprot.writeFieldStop()
8022 
    oprot.writeStructEnd()
8023 
 
8024 
  def validate(self):
8025 
    return
8026 
 
8027 
 
8028 
  def __repr__(self):
8029 
    L = ['%s=%r' % (key, value)
8030 
      for key, value in self.__dict__.iteritems()]
8031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8032 
 
8033 
  def __eq__(self, other):
8034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8035 
 
8036 
  def __ne__(self, other):
8037 
    return not (self == other)
8038 
 
8039 
class markItemAsContentComplete_args:
8040 
  """
8041 
  Attributes:
8042 
   - entityId
8043 
   - category
8044 
   - brand
8045 
   - modelName
8046 
   - modelNumber
8047 
  """
8048 
 
8049 
  thrift_spec = (
8050 
    None, # 0
8051 
    (1, TType.I64, 'entityId', None, None, ), # 1
8052 
    (2, TType.I64, 'category', None, None, ), # 2
8053 
    (3, TType.STRING, 'brand', None, None, ), # 3
8054 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8055 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
8056 
  )
8057 
 
8058 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
8059 
    self.entityId = entityId
8060 
    self.category = category
8061 
    self.brand = brand
8062 
    self.modelName = modelName
8063 
    self.modelNumber = modelNumber
8064 
 
8065 
  def read(self, iprot):
8066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8068 
      return
8069 
    iprot.readStructBegin()
8070 
    while True:
8071 
      (fname, ftype, fid) = iprot.readFieldBegin()
8072 
      if ftype == TType.STOP:
8073 
        break
8074 
      if fid == 1:
8075 
        if ftype == TType.I64:
8076 
          self.entityId = iprot.readI64();
8077 
        else:
8078 
          iprot.skip(ftype)
8079 
      elif fid == 2:
8080 
        if ftype == TType.I64:
8081 
          self.category = iprot.readI64();
8082 
        else:
8083 
          iprot.skip(ftype)
8084 
      elif fid == 3:
8085 
        if ftype == TType.STRING:
8086 
          self.brand = iprot.readString();
8087 
        else:
8088 
          iprot.skip(ftype)
8089 
      elif fid == 4:
8090 
        if ftype == TType.STRING:
8091 
          self.modelName = iprot.readString();
8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      elif fid == 5:
8095 
        if ftype == TType.STRING:
8096 
          self.modelNumber = iprot.readString();
8097 
        else:
8098 
          iprot.skip(ftype)
8099 
      else:
8100 
        iprot.skip(ftype)
8101 
      iprot.readFieldEnd()
8102 
    iprot.readStructEnd()
8103 
 
8104 
  def write(self, oprot):
8105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8107 
      return
8108 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8109 
    if self.entityId is not None:
8110 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8111 
      oprot.writeI64(self.entityId)
8112 
      oprot.writeFieldEnd()
8113 
    if self.category is not None:
8114 
      oprot.writeFieldBegin('category', TType.I64, 2)
8115 
      oprot.writeI64(self.category)
8116 
      oprot.writeFieldEnd()
8117 
    if self.brand is not None:
8118 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8119 
      oprot.writeString(self.brand)
8120 
      oprot.writeFieldEnd()
8121 
    if self.modelName is not None:
8122 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8123 
      oprot.writeString(self.modelName)
8124 
      oprot.writeFieldEnd()
8125 
    if self.modelNumber is not None:
8126 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8127 
      oprot.writeString(self.modelNumber)
8128 
      oprot.writeFieldEnd()
8129 
    oprot.writeFieldStop()
8130 
    oprot.writeStructEnd()
8131 
 
8132 
  def validate(self):
8133 
    return
8134 
 
8135 
 
8136 
  def __repr__(self):
8137 
    L = ['%s=%r' % (key, value)
8138 
      for key, value in self.__dict__.iteritems()]
8139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8140 
 
8141 
  def __eq__(self, other):
8142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8143 
 
8144 
  def __ne__(self, other):
8145 
    return not (self == other)
8146 
 
8147 
class markItemAsContentComplete_result:
8148 
  """
8149 
  Attributes:
8150 
   - success
8151 
   - cex
8152 
  """
8153 
 
8154 
  thrift_spec = (
8155 
    (0, TType.BOOL, 'success', None, None, ), # 0
8156 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8157 
  )
8158 
 
8159 
  def __init__(self, success=None, cex=None,):
8160 
    self.success = success
8161 
    self.cex = cex
8162 
 
8163 
  def read(self, iprot):
8164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8166 
      return
8167 
    iprot.readStructBegin()
8168 
    while True:
8169 
      (fname, ftype, fid) = iprot.readFieldBegin()
8170 
      if ftype == TType.STOP:
8171 
        break
8172 
      if fid == 0:
8173 
        if ftype == TType.BOOL:
8174 
          self.success = iprot.readBool();
8175 
        else:
8176 
          iprot.skip(ftype)
8177 
      elif fid == 1:
8178 
        if ftype == TType.STRUCT:
8179 
          self.cex = CatalogServiceException()
8180 
          self.cex.read(iprot)
8181 
        else:
8182 
          iprot.skip(ftype)
8183 
      else:
8184 
        iprot.skip(ftype)
8185 
      iprot.readFieldEnd()
8186 
    iprot.readStructEnd()
8187 
 
8188 
  def write(self, oprot):
8189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8191 
      return
8192 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8193 
    if self.success is not None:
8194 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8195 
      oprot.writeBool(self.success)
8196 
      oprot.writeFieldEnd()
8197 
    if self.cex is not None:
8198 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8199 
      self.cex.write(oprot)
8200 
      oprot.writeFieldEnd()
8201 
    oprot.writeFieldStop()
8202 
    oprot.writeStructEnd()
8203 
 
8204 
  def validate(self):
8205 
    return
8206 
 
8207 
 
8208 
  def __repr__(self):
8209 
    L = ['%s=%r' % (key, value)
8210 
      for key, value in self.__dict__.iteritems()]
8211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8212 
 
8213 
  def __eq__(self, other):
8214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8215 
 
8216 
  def __ne__(self, other):
8217 
    return not (self == other)
8218 
 
8219 
class getAllItemsInRange_args:
8220 
  """
8221 
  Attributes:
8222 
   - offset
8223 
   - limit
8224 
  """
8225 
 
8226 
  thrift_spec = (
8227 
    None, # 0
8228 
    (1, TType.I64, 'offset', None, None, ), # 1
8229 
    (2, TType.I64, 'limit', None, None, ), # 2
8230 
  )
8231 
 
8232 
  def __init__(self, offset=None, limit=None,):
8233 
    self.offset = offset
8234 
    self.limit = limit
8235 
 
8236 
  def read(self, iprot):
8237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8239 
      return
8240 
    iprot.readStructBegin()
8241 
    while True:
8242 
      (fname, ftype, fid) = iprot.readFieldBegin()
8243 
      if ftype == TType.STOP:
8244 
        break
8245 
      if fid == 1:
8246 
        if ftype == TType.I64:
8247 
          self.offset = iprot.readI64();
8248 
        else:
8249 
          iprot.skip(ftype)
8250 
      elif fid == 2:
8251 
        if ftype == TType.I64:
8252 
          self.limit = iprot.readI64();
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('getAllItemsInRange_args')
8265 
    if self.offset is not None:
8266 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8267 
      oprot.writeI64(self.offset)
8268 
      oprot.writeFieldEnd()
8269 
    if self.limit is not None:
8270 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8271 
      oprot.writeI64(self.limit)
8272 
      oprot.writeFieldEnd()
8273 
    oprot.writeFieldStop()
8274 
    oprot.writeStructEnd()
8275 
 
8276 
  def validate(self):
8277 
    return
8278 
 
8279 
 
8280 
  def __repr__(self):
8281 
    L = ['%s=%r' % (key, value)
8282 
      for key, value in self.__dict__.iteritems()]
8283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8284 
 
8285 
  def __eq__(self, other):
8286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8287 
 
8288 
  def __ne__(self, other):
8289 
    return not (self == other)
8290 
 
8291 
class getAllItemsInRange_result:
8292 
  """
8293 
  Attributes:
8294 
   - success
8295 
   - cex
8296 
  """
8297 
 
8298 
  thrift_spec = (
8299 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8300 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8301 
  )
8302 
 
8303 
  def __init__(self, success=None, cex=None,):
8304 
    self.success = success
8305 
    self.cex = cex
8306 
 
8307 
  def read(self, iprot):
8308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8310 
      return
8311 
    iprot.readStructBegin()
8312 
    while True:
8313 
      (fname, ftype, fid) = iprot.readFieldBegin()
8314 
      if ftype == TType.STOP:
8315 
        break
8316 
      if fid == 0:
8317 
        if ftype == TType.LIST:
8318 
          self.success = []
8590 kshitij.so 8319 
          (_etype77, _size74) = iprot.readListBegin()
8320 
          for _i78 in xrange(_size74):
8321 
            _elem79 = Item()
8322 
            _elem79.read(iprot)
8323 
            self.success.append(_elem79)
5944 mandeep.dh 8324 
          iprot.readListEnd()
8325 
        else:
8326 
          iprot.skip(ftype)
8327 
      elif fid == 1:
8328 
        if ftype == TType.STRUCT:
8329 
          self.cex = CatalogServiceException()
8330 
          self.cex.read(iprot)
8331 
        else:
8332 
          iprot.skip(ftype)
8333 
      else:
8334 
        iprot.skip(ftype)
8335 
      iprot.readFieldEnd()
8336 
    iprot.readStructEnd()
8337 
 
8338 
  def write(self, oprot):
8339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8341 
      return
8342 
    oprot.writeStructBegin('getAllItemsInRange_result')
8343 
    if self.success is not None:
8344 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8345 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8346 
      for iter80 in self.success:
8347 
        iter80.write(oprot)
5944 mandeep.dh 8348 
      oprot.writeListEnd()
8349 
      oprot.writeFieldEnd()
8350 
    if self.cex is not None:
8351 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8352 
      self.cex.write(oprot)
8353 
      oprot.writeFieldEnd()
8354 
    oprot.writeFieldStop()
8355 
    oprot.writeStructEnd()
8356 
 
8357 
  def validate(self):
8358 
    return
8359 
 
8360 
 
8361 
  def __repr__(self):
8362 
    L = ['%s=%r' % (key, value)
8363 
      for key, value in self.__dict__.iteritems()]
8364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8365 
 
8366 
  def __eq__(self, other):
8367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8368 
 
8369 
  def __ne__(self, other):
8370 
    return not (self == other)
8371 
 
8372 
class getAllItemsByStatusInRange_args:
8373 
  """
8374 
  Attributes:
8375 
   - itemStatus
8376 
   - offset
8377 
   - limit
8378 
  """
8379 
 
8380 
  thrift_spec = (
8381 
    None, # 0
8382 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8383 
    (2, TType.I64, 'offset', None, None, ), # 2
8384 
    (3, TType.I64, 'limit', None, None, ), # 3
8385 
  )
8386 
 
8387 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8388 
    self.itemStatus = itemStatus
8389 
    self.offset = offset
8390 
    self.limit = limit
8391 
 
8392 
  def read(self, iprot):
8393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8395 
      return
8396 
    iprot.readStructBegin()
8397 
    while True:
8398 
      (fname, ftype, fid) = iprot.readFieldBegin()
8399 
      if ftype == TType.STOP:
8400 
        break
8401 
      if fid == 1:
8402 
        if ftype == TType.I32:
8403 
          self.itemStatus = iprot.readI32();
8404 
        else:
8405 
          iprot.skip(ftype)
8406 
      elif fid == 2:
8407 
        if ftype == TType.I64:
8408 
          self.offset = iprot.readI64();
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      elif fid == 3:
8412 
        if ftype == TType.I64:
8413 
          self.limit = iprot.readI64();
8414 
        else:
8415 
          iprot.skip(ftype)
8416 
      else:
8417 
        iprot.skip(ftype)
8418 
      iprot.readFieldEnd()
8419 
    iprot.readStructEnd()
8420 
 
8421 
  def write(self, oprot):
8422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8424 
      return
8425 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8426 
    if self.itemStatus is not None:
8427 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8428 
      oprot.writeI32(self.itemStatus)
8429 
      oprot.writeFieldEnd()
8430 
    if self.offset is not None:
8431 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8432 
      oprot.writeI64(self.offset)
8433 
      oprot.writeFieldEnd()
8434 
    if self.limit is not None:
8435 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8436 
      oprot.writeI64(self.limit)
8437 
      oprot.writeFieldEnd()
8438 
    oprot.writeFieldStop()
8439 
    oprot.writeStructEnd()
8440 
 
8441 
  def validate(self):
8442 
    return
8443 
 
8444 
 
8445 
  def __repr__(self):
8446 
    L = ['%s=%r' % (key, value)
8447 
      for key, value in self.__dict__.iteritems()]
8448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8449 
 
8450 
  def __eq__(self, other):
8451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8452 
 
8453 
  def __ne__(self, other):
8454 
    return not (self == other)
8455 
 
8456 
class getAllItemsByStatusInRange_result:
8457 
  """
8458 
  Attributes:
8459 
   - success
8460 
   - cex
8461 
  """
8462 
 
8463 
  thrift_spec = (
8464 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8465 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8466 
  )
8467 
 
8468 
  def __init__(self, success=None, cex=None,):
8469 
    self.success = success
8470 
    self.cex = cex
8471 
 
8472 
  def read(self, iprot):
8473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8475 
      return
8476 
    iprot.readStructBegin()
8477 
    while True:
8478 
      (fname, ftype, fid) = iprot.readFieldBegin()
8479 
      if ftype == TType.STOP:
8480 
        break
8481 
      if fid == 0:
8482 
        if ftype == TType.LIST:
8483 
          self.success = []
8590 kshitij.so 8484 
          (_etype84, _size81) = iprot.readListBegin()
8485 
          for _i85 in xrange(_size81):
8486 
            _elem86 = Item()
8487 
            _elem86.read(iprot)
8488 
            self.success.append(_elem86)
5944 mandeep.dh 8489 
          iprot.readListEnd()
8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      elif fid == 1:
8493 
        if ftype == TType.STRUCT:
8494 
          self.cex = CatalogServiceException()
8495 
          self.cex.read(iprot)
8496 
        else:
8497 
          iprot.skip(ftype)
8498 
      else:
8499 
        iprot.skip(ftype)
8500 
      iprot.readFieldEnd()
8501 
    iprot.readStructEnd()
8502 
 
8503 
  def write(self, oprot):
8504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8506 
      return
8507 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8508 
    if self.success is not None:
8509 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8510 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8511 
      for iter87 in self.success:
8512 
        iter87.write(oprot)
5944 mandeep.dh 8513 
      oprot.writeListEnd()
8514 
      oprot.writeFieldEnd()
8515 
    if self.cex is not None:
8516 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8517 
      self.cex.write(oprot)
8518 
      oprot.writeFieldEnd()
8519 
    oprot.writeFieldStop()
8520 
    oprot.writeStructEnd()
8521 
 
8522 
  def validate(self):
8523 
    return
8524 
 
8525 
 
8526 
  def __repr__(self):
8527 
    L = ['%s=%r' % (key, value)
8528 
      for key, value in self.__dict__.iteritems()]
8529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8530 
 
8531 
  def __eq__(self, other):
8532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8533 
 
8534 
  def __ne__(self, other):
8535 
    return not (self == other)
8536 
 
8537 
class getItemCountByStatus_args:
8538 
  """
8539 
  Attributes:
8540 
   - useStatus
8541 
   - itemStatus
8542 
  """
8543 
 
8544 
  thrift_spec = (
8545 
    None, # 0
8546 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8547 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8548 
  )
8549 
 
8550 
  def __init__(self, useStatus=None, itemStatus=None,):
8551 
    self.useStatus = useStatus
8552 
    self.itemStatus = itemStatus
8553 
 
8554 
  def read(self, iprot):
8555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8557 
      return
8558 
    iprot.readStructBegin()
8559 
    while True:
8560 
      (fname, ftype, fid) = iprot.readFieldBegin()
8561 
      if ftype == TType.STOP:
8562 
        break
8563 
      if fid == 1:
8564 
        if ftype == TType.BOOL:
8565 
          self.useStatus = iprot.readBool();
8566 
        else:
8567 
          iprot.skip(ftype)
8568 
      elif fid == 2:
8569 
        if ftype == TType.I32:
8570 
          self.itemStatus = iprot.readI32();
8571 
        else:
8572 
          iprot.skip(ftype)
8573 
      else:
8574 
        iprot.skip(ftype)
8575 
      iprot.readFieldEnd()
8576 
    iprot.readStructEnd()
8577 
 
8578 
  def write(self, oprot):
8579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8581 
      return
8582 
    oprot.writeStructBegin('getItemCountByStatus_args')
8583 
    if self.useStatus is not None:
8584 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8585 
      oprot.writeBool(self.useStatus)
8586 
      oprot.writeFieldEnd()
8587 
    if self.itemStatus is not None:
8588 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8589 
      oprot.writeI32(self.itemStatus)
8590 
      oprot.writeFieldEnd()
8591 
    oprot.writeFieldStop()
8592 
    oprot.writeStructEnd()
8593 
 
8594 
  def validate(self):
8595 
    return
8596 
 
8597 
 
8598 
  def __repr__(self):
8599 
    L = ['%s=%r' % (key, value)
8600 
      for key, value in self.__dict__.iteritems()]
8601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8602 
 
8603 
  def __eq__(self, other):
8604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8605 
 
8606 
  def __ne__(self, other):
8607 
    return not (self == other)
8608 
 
8609 
class getItemCountByStatus_result:
8610 
  """
8611 
  Attributes:
8612 
   - success
8613 
  """
8614 
 
8615 
  thrift_spec = (
8616 
    (0, TType.I32, 'success', None, None, ), # 0
8617 
  )
8618 
 
8619 
  def __init__(self, success=None,):
8620 
    self.success = success
8621 
 
8622 
  def read(self, iprot):
8623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8625 
      return
8626 
    iprot.readStructBegin()
8627 
    while True:
8628 
      (fname, ftype, fid) = iprot.readFieldBegin()
8629 
      if ftype == TType.STOP:
8630 
        break
8631 
      if fid == 0:
8632 
        if ftype == TType.I32:
8633 
          self.success = iprot.readI32();
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('getItemCountByStatus_result')
8646 
    if self.success is not None:
8647 
      oprot.writeFieldBegin('success', TType.I32, 0)
8648 
      oprot.writeI32(self.success)
8649 
      oprot.writeFieldEnd()
8650 
    oprot.writeFieldStop()
8651 
    oprot.writeStructEnd()
8652 
 
8653 
  def validate(self):
8654 
    return
8655 
 
8656 
 
8657 
  def __repr__(self):
8658 
    L = ['%s=%r' % (key, value)
8659 
      for key, value in self.__dict__.iteritems()]
8660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8661 
 
8662 
  def __eq__(self, other):
8663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8664 
 
8665 
  def __ne__(self, other):
8666 
    return not (self == other)
8667 
 
8668 
class getBestSellers_args:
8669 
 
8670 
  thrift_spec = (
8671 
  )
8672 
 
8673 
  def read(self, iprot):
8674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8676 
      return
8677 
    iprot.readStructBegin()
8678 
    while True:
8679 
      (fname, ftype, fid) = iprot.readFieldBegin()
8680 
      if ftype == TType.STOP:
8681 
        break
8682 
      else:
8683 
        iprot.skip(ftype)
8684 
      iprot.readFieldEnd()
8685 
    iprot.readStructEnd()
8686 
 
8687 
  def write(self, oprot):
8688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8690 
      return
8691 
    oprot.writeStructBegin('getBestSellers_args')
8692 
    oprot.writeFieldStop()
8693 
    oprot.writeStructEnd()
8694 
 
8695 
  def validate(self):
8696 
    return
8697 
 
8698 
 
8699 
  def __repr__(self):
8700 
    L = ['%s=%r' % (key, value)
8701 
      for key, value in self.__dict__.iteritems()]
8702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8703 
 
8704 
  def __eq__(self, other):
8705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8706 
 
8707 
  def __ne__(self, other):
8708 
    return not (self == other)
8709 
 
8710 
class getBestSellers_result:
8711 
  """
8712 
  Attributes:
8713 
   - success
8714 
   - isex
8715 
  """
8716 
 
8717 
  thrift_spec = (
8718 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8719 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8720 
  )
8721 
 
8722 
  def __init__(self, success=None, isex=None,):
8723 
    self.success = success
8724 
    self.isex = isex
8725 
 
8726 
  def read(self, iprot):
8727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8729 
      return
8730 
    iprot.readStructBegin()
8731 
    while True:
8732 
      (fname, ftype, fid) = iprot.readFieldBegin()
8733 
      if ftype == TType.STOP:
8734 
        break
8735 
      if fid == 0:
8736 
        if ftype == TType.LIST:
8737 
          self.success = []
8590 kshitij.so 8738 
          (_etype91, _size88) = iprot.readListBegin()
8739 
          for _i92 in xrange(_size88):
8740 
            _elem93 = Item()
8741 
            _elem93.read(iprot)
8742 
            self.success.append(_elem93)
5944 mandeep.dh 8743 
          iprot.readListEnd()
8744 
        else:
8745 
          iprot.skip(ftype)
8746 
      elif fid == 1:
8747 
        if ftype == TType.STRUCT:
8748 
          self.isex = CatalogServiceException()
8749 
          self.isex.read(iprot)
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('getBestSellers_result')
8762 
    if self.success is not None:
8763 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8764 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8765 
      for iter94 in self.success:
8766 
        iter94.write(oprot)
5944 mandeep.dh 8767 
      oprot.writeListEnd()
8768 
      oprot.writeFieldEnd()
8769 
    if self.isex is not None:
8770 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8771 
      self.isex.write(oprot)
8772 
      oprot.writeFieldEnd()
8773 
    oprot.writeFieldStop()
8774 
    oprot.writeStructEnd()
8775 
 
8776 
  def validate(self):
8777 
    return
8778 
 
8779 
 
8780 
  def __repr__(self):
8781 
    L = ['%s=%r' % (key, value)
8782 
      for key, value in self.__dict__.iteritems()]
8783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8784 
 
8785 
  def __eq__(self, other):
8786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8787 
 
8788 
  def __ne__(self, other):
8789 
    return not (self == other)
8790 
 
8791 
class getBestSellersCatalogIds_args:
8792 
  """
8793 
  Attributes:
8794 
   - beginIndex
8795 
   - totalItems
8796 
   - brand
8797 
   - category
8798 
  """
8799 
 
8800 
  thrift_spec = (
8801 
    None, # 0
8802 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8803 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8804 
    (3, TType.STRING, 'brand', None, None, ), # 3
8805 
    (4, TType.I64, 'category', None, None, ), # 4
8806 
  )
8807 
 
8808 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8809 
    self.beginIndex = beginIndex
8810 
    self.totalItems = totalItems
8811 
    self.brand = brand
8812 
    self.category = category
8813 
 
8814 
  def read(self, iprot):
8815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8817 
      return
8818 
    iprot.readStructBegin()
8819 
    while True:
8820 
      (fname, ftype, fid) = iprot.readFieldBegin()
8821 
      if ftype == TType.STOP:
8822 
        break
8823 
      if fid == 1:
8824 
        if ftype == TType.I64:
8825 
          self.beginIndex = iprot.readI64();
8826 
        else:
8827 
          iprot.skip(ftype)
8828 
      elif fid == 2:
8829 
        if ftype == TType.I64:
8830 
          self.totalItems = iprot.readI64();
8831 
        else:
8832 
          iprot.skip(ftype)
8833 
      elif fid == 3:
8834 
        if ftype == TType.STRING:
8835 
          self.brand = iprot.readString();
8836 
        else:
8837 
          iprot.skip(ftype)
8838 
      elif fid == 4:
8839 
        if ftype == TType.I64:
8840 
          self.category = iprot.readI64();
8841 
        else:
8842 
          iprot.skip(ftype)
8843 
      else:
8844 
        iprot.skip(ftype)
8845 
      iprot.readFieldEnd()
8846 
    iprot.readStructEnd()
8847 
 
8848 
  def write(self, oprot):
8849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8851 
      return
8852 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8853 
    if self.beginIndex is not None:
8854 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8855 
      oprot.writeI64(self.beginIndex)
8856 
      oprot.writeFieldEnd()
8857 
    if self.totalItems is not None:
8858 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8859 
      oprot.writeI64(self.totalItems)
8860 
      oprot.writeFieldEnd()
8861 
    if self.brand is not None:
8862 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8863 
      oprot.writeString(self.brand)
8864 
      oprot.writeFieldEnd()
8865 
    if self.category is not None:
8866 
      oprot.writeFieldBegin('category', TType.I64, 4)
8867 
      oprot.writeI64(self.category)
8868 
      oprot.writeFieldEnd()
8869 
    oprot.writeFieldStop()
8870 
    oprot.writeStructEnd()
8871 
 
8872 
  def validate(self):
8873 
    return
8874 
 
8875 
 
8876 
  def __repr__(self):
8877 
    L = ['%s=%r' % (key, value)
8878 
      for key, value in self.__dict__.iteritems()]
8879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8880 
 
8881 
  def __eq__(self, other):
8882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8883 
 
8884 
  def __ne__(self, other):
8885 
    return not (self == other)
8886 
 
8887 
class getBestSellersCatalogIds_result:
8888 
  """
8889 
  Attributes:
8890 
   - success
8891 
   - cex
8892 
  """
8893 
 
8894 
  thrift_spec = (
8895 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8896 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8897 
  )
8898 
 
8899 
  def __init__(self, success=None, cex=None,):
8900 
    self.success = success
8901 
    self.cex = cex
8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 0:
8913 
        if ftype == TType.LIST:
8914 
          self.success = []
8590 kshitij.so 8915 
          (_etype98, _size95) = iprot.readListBegin()
8916 
          for _i99 in xrange(_size95):
8917 
            _elem100 = iprot.readI64();
8918 
            self.success.append(_elem100)
5944 mandeep.dh 8919 
          iprot.readListEnd()
8920 
        else:
8921 
          iprot.skip(ftype)
8922 
      elif fid == 1:
8923 
        if ftype == TType.STRUCT:
8924 
          self.cex = CatalogServiceException()
8925 
          self.cex.read(iprot)
8926 
        else:
8927 
          iprot.skip(ftype)
8928 
      else:
8929 
        iprot.skip(ftype)
8930 
      iprot.readFieldEnd()
8931 
    iprot.readStructEnd()
8932 
 
8933 
  def write(self, oprot):
8934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8936 
      return
8937 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8938 
    if self.success is not None:
8939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8940 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 8941 
      for iter101 in self.success:
8942 
        oprot.writeI64(iter101)
5944 mandeep.dh 8943 
      oprot.writeListEnd()
8944 
      oprot.writeFieldEnd()
8945 
    if self.cex is not None:
8946 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8947 
      self.cex.write(oprot)
8948 
      oprot.writeFieldEnd()
8949 
    oprot.writeFieldStop()
8950 
    oprot.writeStructEnd()
8951 
 
8952 
  def validate(self):
8953 
    return
8954 
 
8955 
 
8956 
  def __repr__(self):
8957 
    L = ['%s=%r' % (key, value)
8958 
      for key, value in self.__dict__.iteritems()]
8959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8960 
 
8961 
  def __eq__(self, other):
8962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8963 
 
8964 
  def __ne__(self, other):
8965 
    return not (self == other)
8966 
 
8967 
class getBestSellersCount_args:
8968 
 
8969 
  thrift_spec = (
8970 
  )
8971 
 
8972 
  def read(self, iprot):
8973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8975 
      return
8976 
    iprot.readStructBegin()
8977 
    while True:
8978 
      (fname, ftype, fid) = iprot.readFieldBegin()
8979 
      if ftype == TType.STOP:
8980 
        break
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('getBestSellersCount_args')
8991 
    oprot.writeFieldStop()
8992 
    oprot.writeStructEnd()
8993 
 
8994 
  def validate(self):
8995 
    return
8996 
 
8997 
 
8998 
  def __repr__(self):
8999 
    L = ['%s=%r' % (key, value)
9000 
      for key, value in self.__dict__.iteritems()]
9001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9002 
 
9003 
  def __eq__(self, other):
9004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9005 
 
9006 
  def __ne__(self, other):
9007 
    return not (self == other)
9008 
 
9009 
class getBestSellersCount_result:
9010 
  """
9011 
  Attributes:
9012 
   - success
9013 
   - cex
9014 
  """
9015 
 
9016 
  thrift_spec = (
9017 
    (0, TType.I64, 'success', None, None, ), # 0
9018 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9019 
  )
9020 
 
9021 
  def __init__(self, success=None, cex=None,):
9022 
    self.success = success
9023 
    self.cex = cex
9024 
 
9025 
  def read(self, iprot):
9026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9028 
      return
9029 
    iprot.readStructBegin()
9030 
    while True:
9031 
      (fname, ftype, fid) = iprot.readFieldBegin()
9032 
      if ftype == TType.STOP:
9033 
        break
9034 
      if fid == 0:
9035 
        if ftype == TType.I64:
9036 
          self.success = iprot.readI64();
9037 
        else:
9038 
          iprot.skip(ftype)
9039 
      elif fid == 1:
9040 
        if ftype == TType.STRUCT:
9041 
          self.cex = CatalogServiceException()
9042 
          self.cex.read(iprot)
9043 
        else:
9044 
          iprot.skip(ftype)
9045 
      else:
9046 
        iprot.skip(ftype)
9047 
      iprot.readFieldEnd()
9048 
    iprot.readStructEnd()
9049 
 
9050 
  def write(self, oprot):
9051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9053 
      return
9054 
    oprot.writeStructBegin('getBestSellersCount_result')
9055 
    if self.success is not None:
9056 
      oprot.writeFieldBegin('success', TType.I64, 0)
9057 
      oprot.writeI64(self.success)
9058 
      oprot.writeFieldEnd()
9059 
    if self.cex is not None:
9060 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9061 
      self.cex.write(oprot)
9062 
      oprot.writeFieldEnd()
9063 
    oprot.writeFieldStop()
9064 
    oprot.writeStructEnd()
9065 
 
9066 
  def validate(self):
9067 
    return
9068 
 
9069 
 
9070 
  def __repr__(self):
9071 
    L = ['%s=%r' % (key, value)
9072 
      for key, value in self.__dict__.iteritems()]
9073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9074 
 
9075 
  def __eq__(self, other):
9076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9077 
 
9078 
  def __ne__(self, other):
9079 
    return not (self == other)
9080 
 
9081 
class getBestDeals_args:
9082 
 
9083 
  thrift_spec = (
9084 
  )
9085 
 
9086 
  def read(self, iprot):
9087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9089 
      return
9090 
    iprot.readStructBegin()
9091 
    while True:
9092 
      (fname, ftype, fid) = iprot.readFieldBegin()
9093 
      if ftype == TType.STOP:
9094 
        break
9095 
      else:
9096 
        iprot.skip(ftype)
9097 
      iprot.readFieldEnd()
9098 
    iprot.readStructEnd()
9099 
 
9100 
  def write(self, oprot):
9101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9103 
      return
9104 
    oprot.writeStructBegin('getBestDeals_args')
9105 
    oprot.writeFieldStop()
9106 
    oprot.writeStructEnd()
9107 
 
9108 
  def validate(self):
9109 
    return
9110 
 
9111 
 
9112 
  def __repr__(self):
9113 
    L = ['%s=%r' % (key, value)
9114 
      for key, value in self.__dict__.iteritems()]
9115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9116 
 
9117 
  def __eq__(self, other):
9118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9119 
 
9120 
  def __ne__(self, other):
9121 
    return not (self == other)
9122 
 
9123 
class getBestDeals_result:
9124 
  """
9125 
  Attributes:
9126 
   - success
9127 
   - isex
9128 
  """
9129 
 
9130 
  thrift_spec = (
9131 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9132 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9133 
  )
9134 
 
9135 
  def __init__(self, success=None, isex=None,):
9136 
    self.success = success
9137 
    self.isex = isex
9138 
 
9139 
  def read(self, iprot):
9140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9142 
      return
9143 
    iprot.readStructBegin()
9144 
    while True:
9145 
      (fname, ftype, fid) = iprot.readFieldBegin()
9146 
      if ftype == TType.STOP:
9147 
        break
9148 
      if fid == 0:
9149 
        if ftype == TType.LIST:
9150 
          self.success = []
8590 kshitij.so 9151 
          (_etype105, _size102) = iprot.readListBegin()
9152 
          for _i106 in xrange(_size102):
9153 
            _elem107 = Item()
9154 
            _elem107.read(iprot)
9155 
            self.success.append(_elem107)
5944 mandeep.dh 9156 
          iprot.readListEnd()
9157 
        else:
9158 
          iprot.skip(ftype)
9159 
      elif fid == 1:
9160 
        if ftype == TType.STRUCT:
9161 
          self.isex = CatalogServiceException()
9162 
          self.isex.read(iprot)
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getBestDeals_result')
9175 
    if self.success is not None:
9176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9178 
      for iter108 in self.success:
9179 
        iter108.write(oprot)
5944 mandeep.dh 9180 
      oprot.writeListEnd()
9181 
      oprot.writeFieldEnd()
9182 
    if self.isex is not None:
9183 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9184 
      self.isex.write(oprot)
9185 
      oprot.writeFieldEnd()
9186 
    oprot.writeFieldStop()
9187 
    oprot.writeStructEnd()
9188 
 
9189 
  def validate(self):
9190 
    return
9191 
 
9192 
 
9193 
  def __repr__(self):
9194 
    L = ['%s=%r' % (key, value)
9195 
      for key, value in self.__dict__.iteritems()]
9196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9197 
 
9198 
  def __eq__(self, other):
9199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9200 
 
9201 
  def __ne__(self, other):
9202 
    return not (self == other)
9203 
 
9204 
class getBestDealsCatalogIds_args:
9205 
  """
9206 
  Attributes:
9207 
   - beginIndex
9208 
   - totalItems
9209 
   - brand
9210 
   - category
9211 
  """
9212 
 
9213 
  thrift_spec = (
9214 
    None, # 0
9215 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9216 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9217 
    (3, TType.STRING, 'brand', None, None, ), # 3
9218 
    (4, TType.I64, 'category', None, None, ), # 4
9219 
  )
9220 
 
9221 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9222 
    self.beginIndex = beginIndex
9223 
    self.totalItems = totalItems
9224 
    self.brand = brand
9225 
    self.category = category
9226 
 
9227 
  def read(self, iprot):
9228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9230 
      return
9231 
    iprot.readStructBegin()
9232 
    while True:
9233 
      (fname, ftype, fid) = iprot.readFieldBegin()
9234 
      if ftype == TType.STOP:
9235 
        break
9236 
      if fid == 1:
9237 
        if ftype == TType.I64:
9238 
          self.beginIndex = iprot.readI64();
9239 
        else:
9240 
          iprot.skip(ftype)
9241 
      elif fid == 2:
9242 
        if ftype == TType.I64:
9243 
          self.totalItems = iprot.readI64();
9244 
        else:
9245 
          iprot.skip(ftype)
9246 
      elif fid == 3:
9247 
        if ftype == TType.STRING:
9248 
          self.brand = iprot.readString();
9249 
        else:
9250 
          iprot.skip(ftype)
9251 
      elif fid == 4:
9252 
        if ftype == TType.I64:
9253 
          self.category = iprot.readI64();
9254 
        else:
9255 
          iprot.skip(ftype)
9256 
      else:
9257 
        iprot.skip(ftype)
9258 
      iprot.readFieldEnd()
9259 
    iprot.readStructEnd()
9260 
 
9261 
  def write(self, oprot):
9262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9264 
      return
9265 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9266 
    if self.beginIndex is not None:
9267 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9268 
      oprot.writeI64(self.beginIndex)
9269 
      oprot.writeFieldEnd()
9270 
    if self.totalItems is not None:
9271 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9272 
      oprot.writeI64(self.totalItems)
9273 
      oprot.writeFieldEnd()
9274 
    if self.brand is not None:
9275 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9276 
      oprot.writeString(self.brand)
9277 
      oprot.writeFieldEnd()
9278 
    if self.category is not None:
9279 
      oprot.writeFieldBegin('category', TType.I64, 4)
9280 
      oprot.writeI64(self.category)
9281 
      oprot.writeFieldEnd()
9282 
    oprot.writeFieldStop()
9283 
    oprot.writeStructEnd()
9284 
 
9285 
  def validate(self):
9286 
    return
9287 
 
9288 
 
9289 
  def __repr__(self):
9290 
    L = ['%s=%r' % (key, value)
9291 
      for key, value in self.__dict__.iteritems()]
9292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9293 
 
9294 
  def __eq__(self, other):
9295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9296 
 
9297 
  def __ne__(self, other):
9298 
    return not (self == other)
9299 
 
9300 
class getBestDealsCatalogIds_result:
9301 
  """
9302 
  Attributes:
9303 
   - success
9304 
   - cex
9305 
  """
9306 
 
9307 
  thrift_spec = (
9308 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9309 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9310 
  )
9311 
 
9312 
  def __init__(self, success=None, cex=None,):
9313 
    self.success = success
9314 
    self.cex = cex
9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 0:
9326 
        if ftype == TType.LIST:
9327 
          self.success = []
8590 kshitij.so 9328 
          (_etype112, _size109) = iprot.readListBegin()
9329 
          for _i113 in xrange(_size109):
9330 
            _elem114 = iprot.readI64();
9331 
            self.success.append(_elem114)
5944 mandeep.dh 9332 
          iprot.readListEnd()
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      elif fid == 1:
9336 
        if ftype == TType.STRUCT:
9337 
          self.cex = CatalogServiceException()
9338 
          self.cex.read(iprot)
9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      else:
9342 
        iprot.skip(ftype)
9343 
      iprot.readFieldEnd()
9344 
    iprot.readStructEnd()
9345 
 
9346 
  def write(self, oprot):
9347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9349 
      return
9350 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9351 
    if self.success is not None:
9352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9353 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9354 
      for iter115 in self.success:
9355 
        oprot.writeI64(iter115)
5944 mandeep.dh 9356 
      oprot.writeListEnd()
9357 
      oprot.writeFieldEnd()
9358 
    if self.cex is not None:
9359 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9360 
      self.cex.write(oprot)
9361 
      oprot.writeFieldEnd()
9362 
    oprot.writeFieldStop()
9363 
    oprot.writeStructEnd()
9364 
 
9365 
  def validate(self):
9366 
    return
9367 
 
9368 
 
9369 
  def __repr__(self):
9370 
    L = ['%s=%r' % (key, value)
9371 
      for key, value in self.__dict__.iteritems()]
9372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9373 
 
9374 
  def __eq__(self, other):
9375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9376 
 
9377 
  def __ne__(self, other):
9378 
    return not (self == other)
9379 
 
9380 
class getBestDealsCount_args:
9381 
 
9382 
  thrift_spec = (
9383 
  )
9384 
 
9385 
  def read(self, iprot):
9386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9388 
      return
9389 
    iprot.readStructBegin()
9390 
    while True:
9391 
      (fname, ftype, fid) = iprot.readFieldBegin()
9392 
      if ftype == TType.STOP:
9393 
        break
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('getBestDealsCount_args')
9404 
    oprot.writeFieldStop()
9405 
    oprot.writeStructEnd()
9406 
 
9407 
  def validate(self):
9408 
    return
9409 
 
9410 
 
9411 
  def __repr__(self):
9412 
    L = ['%s=%r' % (key, value)
9413 
      for key, value in self.__dict__.iteritems()]
9414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9415 
 
9416 
  def __eq__(self, other):
9417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9418 
 
9419 
  def __ne__(self, other):
9420 
    return not (self == other)
9421 
 
9422 
class getBestDealsCount_result:
9423 
  """
9424 
  Attributes:
9425 
   - success
9426 
   - cex
9427 
  """
9428 
 
9429 
  thrift_spec = (
9430 
    (0, TType.I64, 'success', None, None, ), # 0
9431 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9432 
  )
9433 
 
9434 
  def __init__(self, success=None, cex=None,):
9435 
    self.success = success
9436 
    self.cex = cex
9437 
 
9438 
  def read(self, iprot):
9439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9441 
      return
9442 
    iprot.readStructBegin()
9443 
    while True:
9444 
      (fname, ftype, fid) = iprot.readFieldBegin()
9445 
      if ftype == TType.STOP:
9446 
        break
9447 
      if fid == 0:
9448 
        if ftype == TType.I64:
9449 
          self.success = iprot.readI64();
9450 
        else:
9451 
          iprot.skip(ftype)
9452 
      elif fid == 1:
9453 
        if ftype == TType.STRUCT:
9454 
          self.cex = CatalogServiceException()
9455 
          self.cex.read(iprot)
9456 
        else:
9457 
          iprot.skip(ftype)
9458 
      else:
9459 
        iprot.skip(ftype)
9460 
      iprot.readFieldEnd()
9461 
    iprot.readStructEnd()
9462 
 
9463 
  def write(self, oprot):
9464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9466 
      return
9467 
    oprot.writeStructBegin('getBestDealsCount_result')
9468 
    if self.success is not None:
9469 
      oprot.writeFieldBegin('success', TType.I64, 0)
9470 
      oprot.writeI64(self.success)
9471 
      oprot.writeFieldEnd()
9472 
    if self.cex is not None:
9473 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9474 
      self.cex.write(oprot)
9475 
      oprot.writeFieldEnd()
9476 
    oprot.writeFieldStop()
9477 
    oprot.writeStructEnd()
9478 
 
9479 
  def validate(self):
9480 
    return
9481 
 
9482 
 
9483 
  def __repr__(self):
9484 
    L = ['%s=%r' % (key, value)
9485 
      for key, value in self.__dict__.iteritems()]
9486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9487 
 
9488 
  def __eq__(self, other):
9489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9490 
 
9491 
  def __ne__(self, other):
9492 
    return not (self == other)
9493 
 
9494 
class getComingSoon_args:
9495 
 
9496 
  thrift_spec = (
9497 
  )
9498 
 
9499 
  def read(self, iprot):
9500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9502 
      return
9503 
    iprot.readStructBegin()
9504 
    while True:
9505 
      (fname, ftype, fid) = iprot.readFieldBegin()
9506 
      if ftype == TType.STOP:
9507 
        break
9508 
      else:
9509 
        iprot.skip(ftype)
9510 
      iprot.readFieldEnd()
9511 
    iprot.readStructEnd()
9512 
 
9513 
  def write(self, oprot):
9514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9516 
      return
9517 
    oprot.writeStructBegin('getComingSoon_args')
9518 
    oprot.writeFieldStop()
9519 
    oprot.writeStructEnd()
9520 
 
9521 
  def validate(self):
9522 
    return
9523 
 
9524 
 
9525 
  def __repr__(self):
9526 
    L = ['%s=%r' % (key, value)
9527 
      for key, value in self.__dict__.iteritems()]
9528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9529 
 
9530 
  def __eq__(self, other):
9531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9532 
 
9533 
  def __ne__(self, other):
9534 
    return not (self == other)
9535 
 
9536 
class getComingSoon_result:
9537 
  """
9538 
  Attributes:
9539 
   - success
9540 
   - isex
9541 
  """
9542 
 
9543 
  thrift_spec = (
9544 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9545 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9546 
  )
9547 
 
9548 
  def __init__(self, success=None, isex=None,):
9549 
    self.success = success
9550 
    self.isex = isex
9551 
 
9552 
  def read(self, iprot):
9553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9555 
      return
9556 
    iprot.readStructBegin()
9557 
    while True:
9558 
      (fname, ftype, fid) = iprot.readFieldBegin()
9559 
      if ftype == TType.STOP:
9560 
        break
9561 
      if fid == 0:
9562 
        if ftype == TType.LIST:
9563 
          self.success = []
8590 kshitij.so 9564 
          (_etype119, _size116) = iprot.readListBegin()
9565 
          for _i120 in xrange(_size116):
9566 
            _elem121 = Item()
9567 
            _elem121.read(iprot)
9568 
            self.success.append(_elem121)
5944 mandeep.dh 9569 
          iprot.readListEnd()
9570 
        else:
9571 
          iprot.skip(ftype)
9572 
      elif fid == 1:
9573 
        if ftype == TType.STRUCT:
9574 
          self.isex = CatalogServiceException()
9575 
          self.isex.read(iprot)
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      else:
9579 
        iprot.skip(ftype)
9580 
      iprot.readFieldEnd()
9581 
    iprot.readStructEnd()
9582 
 
9583 
  def write(self, oprot):
9584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9586 
      return
9587 
    oprot.writeStructBegin('getComingSoon_result')
9588 
    if self.success is not None:
9589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9590 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9591 
      for iter122 in self.success:
9592 
        iter122.write(oprot)
5944 mandeep.dh 9593 
      oprot.writeListEnd()
9594 
      oprot.writeFieldEnd()
9595 
    if self.isex is not None:
9596 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9597 
      self.isex.write(oprot)
9598 
      oprot.writeFieldEnd()
9599 
    oprot.writeFieldStop()
9600 
    oprot.writeStructEnd()
9601 
 
9602 
  def validate(self):
9603 
    return
9604 
 
9605 
 
9606 
  def __repr__(self):
9607 
    L = ['%s=%r' % (key, value)
9608 
      for key, value in self.__dict__.iteritems()]
9609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9610 
 
9611 
  def __eq__(self, other):
9612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9613 
 
9614 
  def __ne__(self, other):
9615 
    return not (self == other)
9616 
 
9617 
class getComingSoonCatalogIds_args:
9618 
  """
9619 
  Attributes:
9620 
   - beginIndex
9621 
   - totalItems
9622 
   - brand
9623 
   - category
9624 
  """
9625 
 
9626 
  thrift_spec = (
9627 
    None, # 0
9628 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9629 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9630 
    (3, TType.STRING, 'brand', None, None, ), # 3
9631 
    (4, TType.I64, 'category', None, None, ), # 4
9632 
  )
9633 
 
9634 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9635 
    self.beginIndex = beginIndex
9636 
    self.totalItems = totalItems
9637 
    self.brand = brand
9638 
    self.category = category
9639 
 
9640 
  def read(self, iprot):
9641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9643 
      return
9644 
    iprot.readStructBegin()
9645 
    while True:
9646 
      (fname, ftype, fid) = iprot.readFieldBegin()
9647 
      if ftype == TType.STOP:
9648 
        break
9649 
      if fid == 1:
9650 
        if ftype == TType.I64:
9651 
          self.beginIndex = iprot.readI64();
9652 
        else:
9653 
          iprot.skip(ftype)
9654 
      elif fid == 2:
9655 
        if ftype == TType.I64:
9656 
          self.totalItems = iprot.readI64();
9657 
        else:
9658 
          iprot.skip(ftype)
9659 
      elif fid == 3:
9660 
        if ftype == TType.STRING:
9661 
          self.brand = iprot.readString();
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 4:
9665 
        if ftype == TType.I64:
9666 
          self.category = iprot.readI64();
9667 
        else:
9668 
          iprot.skip(ftype)
9669 
      else:
9670 
        iprot.skip(ftype)
9671 
      iprot.readFieldEnd()
9672 
    iprot.readStructEnd()
9673 
 
9674 
  def write(self, oprot):
9675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9677 
      return
9678 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9679 
    if self.beginIndex is not None:
9680 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9681 
      oprot.writeI64(self.beginIndex)
9682 
      oprot.writeFieldEnd()
9683 
    if self.totalItems is not None:
9684 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9685 
      oprot.writeI64(self.totalItems)
9686 
      oprot.writeFieldEnd()
9687 
    if self.brand is not None:
9688 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9689 
      oprot.writeString(self.brand)
9690 
      oprot.writeFieldEnd()
9691 
    if self.category is not None:
9692 
      oprot.writeFieldBegin('category', TType.I64, 4)
9693 
      oprot.writeI64(self.category)
9694 
      oprot.writeFieldEnd()
9695 
    oprot.writeFieldStop()
9696 
    oprot.writeStructEnd()
9697 
 
9698 
  def validate(self):
9699 
    return
9700 
 
9701 
 
9702 
  def __repr__(self):
9703 
    L = ['%s=%r' % (key, value)
9704 
      for key, value in self.__dict__.iteritems()]
9705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9706 
 
9707 
  def __eq__(self, other):
9708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9709 
 
9710 
  def __ne__(self, other):
9711 
    return not (self == other)
9712 
 
9713 
class getComingSoonCatalogIds_result:
9714 
  """
9715 
  Attributes:
9716 
   - success
9717 
   - cex
9718 
  """
9719 
 
9720 
  thrift_spec = (
9721 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9722 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9723 
  )
9724 
 
9725 
  def __init__(self, success=None, cex=None,):
9726 
    self.success = success
9727 
    self.cex = cex
9728 
 
9729 
  def read(self, iprot):
9730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9732 
      return
9733 
    iprot.readStructBegin()
9734 
    while True:
9735 
      (fname, ftype, fid) = iprot.readFieldBegin()
9736 
      if ftype == TType.STOP:
9737 
        break
9738 
      if fid == 0:
9739 
        if ftype == TType.LIST:
9740 
          self.success = []
8590 kshitij.so 9741 
          (_etype126, _size123) = iprot.readListBegin()
9742 
          for _i127 in xrange(_size123):
9743 
            _elem128 = iprot.readI64();
9744 
            self.success.append(_elem128)
5944 mandeep.dh 9745 
          iprot.readListEnd()
9746 
        else:
9747 
          iprot.skip(ftype)
9748 
      elif fid == 1:
9749 
        if ftype == TType.STRUCT:
9750 
          self.cex = CatalogServiceException()
9751 
          self.cex.read(iprot)
9752 
        else:
9753 
          iprot.skip(ftype)
9754 
      else:
9755 
        iprot.skip(ftype)
9756 
      iprot.readFieldEnd()
9757 
    iprot.readStructEnd()
9758 
 
9759 
  def write(self, oprot):
9760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9762 
      return
9763 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9764 
    if self.success is not None:
9765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9766 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9767 
      for iter129 in self.success:
9768 
        oprot.writeI64(iter129)
5944 mandeep.dh 9769 
      oprot.writeListEnd()
9770 
      oprot.writeFieldEnd()
9771 
    if self.cex is not None:
9772 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9773 
      self.cex.write(oprot)
9774 
      oprot.writeFieldEnd()
9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
9778 
  def validate(self):
9779 
    return
9780 
 
9781 
 
9782 
  def __repr__(self):
9783 
    L = ['%s=%r' % (key, value)
9784 
      for key, value in self.__dict__.iteritems()]
9785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9786 
 
9787 
  def __eq__(self, other):
9788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9789 
 
9790 
  def __ne__(self, other):
9791 
    return not (self == other)
9792 
 
9793 
class getComingSoonCount_args:
9794 
 
9795 
  thrift_spec = (
9796 
  )
9797 
 
9798 
  def read(self, iprot):
9799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9801 
      return
9802 
    iprot.readStructBegin()
9803 
    while True:
9804 
      (fname, ftype, fid) = iprot.readFieldBegin()
9805 
      if ftype == TType.STOP:
9806 
        break
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('getComingSoonCount_args')
9817 
    oprot.writeFieldStop()
9818 
    oprot.writeStructEnd()
9819 
 
9820 
  def validate(self):
9821 
    return
9822 
 
9823 
 
9824 
  def __repr__(self):
9825 
    L = ['%s=%r' % (key, value)
9826 
      for key, value in self.__dict__.iteritems()]
9827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9828 
 
9829 
  def __eq__(self, other):
9830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9831 
 
9832 
  def __ne__(self, other):
9833 
    return not (self == other)
9834 
 
9835 
class getComingSoonCount_result:
9836 
  """
9837 
  Attributes:
9838 
   - success
9839 
   - cex
9840 
  """
9841 
 
9842 
  thrift_spec = (
9843 
    (0, TType.I64, 'success', None, None, ), # 0
9844 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9845 
  )
9846 
 
9847 
  def __init__(self, success=None, cex=None,):
9848 
    self.success = success
9849 
    self.cex = cex
9850 
 
9851 
  def read(self, iprot):
9852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9854 
      return
9855 
    iprot.readStructBegin()
9856 
    while True:
9857 
      (fname, ftype, fid) = iprot.readFieldBegin()
9858 
      if ftype == TType.STOP:
9859 
        break
9860 
      if fid == 0:
9861 
        if ftype == TType.I64:
9862 
          self.success = iprot.readI64();
9863 
        else:
9864 
          iprot.skip(ftype)
9865 
      elif fid == 1:
9866 
        if ftype == TType.STRUCT:
9867 
          self.cex = CatalogServiceException()
9868 
          self.cex.read(iprot)
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      else:
9872 
        iprot.skip(ftype)
9873 
      iprot.readFieldEnd()
9874 
    iprot.readStructEnd()
9875 
 
9876 
  def write(self, oprot):
9877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9879 
      return
9880 
    oprot.writeStructBegin('getComingSoonCount_result')
9881 
    if self.success is not None:
9882 
      oprot.writeFieldBegin('success', TType.I64, 0)
9883 
      oprot.writeI64(self.success)
9884 
      oprot.writeFieldEnd()
9885 
    if self.cex is not None:
9886 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9887 
      self.cex.write(oprot)
9888 
      oprot.writeFieldEnd()
9889 
    oprot.writeFieldStop()
9890 
    oprot.writeStructEnd()
9891 
 
9892 
  def validate(self):
9893 
    return
9894 
 
9895 
 
9896 
  def __repr__(self):
9897 
    L = ['%s=%r' % (key, value)
9898 
      for key, value in self.__dict__.iteritems()]
9899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9900 
 
9901 
  def __eq__(self, other):
9902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9903 
 
9904 
  def __ne__(self, other):
9905 
    return not (self == other)
9906 
 
9907 
class getLatestArrivals_args:
9908 
 
9909 
  thrift_spec = (
9910 
  )
9911 
 
9912 
  def read(self, iprot):
9913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9915 
      return
9916 
    iprot.readStructBegin()
9917 
    while True:
9918 
      (fname, ftype, fid) = iprot.readFieldBegin()
9919 
      if ftype == TType.STOP:
9920 
        break
9921 
      else:
9922 
        iprot.skip(ftype)
9923 
      iprot.readFieldEnd()
9924 
    iprot.readStructEnd()
9925 
 
9926 
  def write(self, oprot):
9927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9929 
      return
9930 
    oprot.writeStructBegin('getLatestArrivals_args')
9931 
    oprot.writeFieldStop()
9932 
    oprot.writeStructEnd()
9933 
 
9934 
  def validate(self):
9935 
    return
9936 
 
9937 
 
9938 
  def __repr__(self):
9939 
    L = ['%s=%r' % (key, value)
9940 
      for key, value in self.__dict__.iteritems()]
9941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9942 
 
9943 
  def __eq__(self, other):
9944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9945 
 
9946 
  def __ne__(self, other):
9947 
    return not (self == other)
9948 
 
9949 
class getLatestArrivals_result:
9950 
  """
9951 
  Attributes:
9952 
   - success
9953 
   - isex
9954 
  """
9955 
 
9956 
  thrift_spec = (
9957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9958 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9959 
  )
9960 
 
9961 
  def __init__(self, success=None, isex=None,):
9962 
    self.success = success
9963 
    self.isex = isex
9964 
 
9965 
  def read(self, iprot):
9966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9968 
      return
9969 
    iprot.readStructBegin()
9970 
    while True:
9971 
      (fname, ftype, fid) = iprot.readFieldBegin()
9972 
      if ftype == TType.STOP:
9973 
        break
9974 
      if fid == 0:
9975 
        if ftype == TType.LIST:
9976 
          self.success = []
8590 kshitij.so 9977 
          (_etype133, _size130) = iprot.readListBegin()
9978 
          for _i134 in xrange(_size130):
9979 
            _elem135 = Item()
9980 
            _elem135.read(iprot)
9981 
            self.success.append(_elem135)
5944 mandeep.dh 9982 
          iprot.readListEnd()
9983 
        else:
9984 
          iprot.skip(ftype)
9985 
      elif fid == 1:
9986 
        if ftype == TType.STRUCT:
9987 
          self.isex = CatalogServiceException()
9988 
          self.isex.read(iprot)
9989 
        else:
9990 
          iprot.skip(ftype)
9991 
      else:
9992 
        iprot.skip(ftype)
9993 
      iprot.readFieldEnd()
9994 
    iprot.readStructEnd()
9995 
 
9996 
  def write(self, oprot):
9997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9999 
      return
10000 
    oprot.writeStructBegin('getLatestArrivals_result')
10001 
    if self.success is not None:
10002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10004 
      for iter136 in self.success:
10005 
        iter136.write(oprot)
5944 mandeep.dh 10006 
      oprot.writeListEnd()
10007 
      oprot.writeFieldEnd()
10008 
    if self.isex is not None:
10009 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10010 
      self.isex.write(oprot)
10011 
      oprot.writeFieldEnd()
10012 
    oprot.writeFieldStop()
10013 
    oprot.writeStructEnd()
10014 
 
10015 
  def validate(self):
10016 
    return
10017 
 
10018 
 
10019 
  def __repr__(self):
10020 
    L = ['%s=%r' % (key, value)
10021 
      for key, value in self.__dict__.iteritems()]
10022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10023 
 
10024 
  def __eq__(self, other):
10025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10026 
 
10027 
  def __ne__(self, other):
10028 
    return not (self == other)
10029 
 
10030 
class getLatestArrivalsCatalogIds_args:
10031 
  """
10032 
  Attributes:
10033 
   - beginIndex
10034 
   - totalItems
10035 
   - brand
10036 
   - categories
10037 
  """
10038 
 
10039 
  thrift_spec = (
10040 
    None, # 0
10041 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10042 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10043 
    (3, TType.STRING, 'brand', None, None, ), # 3
10044 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10045 
  )
10046 
 
10047 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10048 
    self.beginIndex = beginIndex
10049 
    self.totalItems = totalItems
10050 
    self.brand = brand
10051 
    self.categories = categories
10052 
 
10053 
  def read(self, iprot):
10054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10056 
      return
10057 
    iprot.readStructBegin()
10058 
    while True:
10059 
      (fname, ftype, fid) = iprot.readFieldBegin()
10060 
      if ftype == TType.STOP:
10061 
        break
10062 
      if fid == 1:
10063 
        if ftype == TType.I64:
10064 
          self.beginIndex = iprot.readI64();
10065 
        else:
10066 
          iprot.skip(ftype)
10067 
      elif fid == 2:
10068 
        if ftype == TType.I64:
10069 
          self.totalItems = iprot.readI64();
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      elif fid == 3:
10073 
        if ftype == TType.STRING:
10074 
          self.brand = iprot.readString();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      elif fid == 4:
10078 
        if ftype == TType.LIST:
10079 
          self.categories = []
8590 kshitij.so 10080 
          (_etype140, _size137) = iprot.readListBegin()
10081 
          for _i141 in xrange(_size137):
10082 
            _elem142 = iprot.readI64();
10083 
            self.categories.append(_elem142)
5944 mandeep.dh 10084 
          iprot.readListEnd()
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      else:
10088 
        iprot.skip(ftype)
10089 
      iprot.readFieldEnd()
10090 
    iprot.readStructEnd()
10091 
 
10092 
  def write(self, oprot):
10093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10095 
      return
10096 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10097 
    if self.beginIndex is not None:
10098 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10099 
      oprot.writeI64(self.beginIndex)
10100 
      oprot.writeFieldEnd()
10101 
    if self.totalItems is not None:
10102 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10103 
      oprot.writeI64(self.totalItems)
10104 
      oprot.writeFieldEnd()
10105 
    if self.brand is not None:
10106 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10107 
      oprot.writeString(self.brand)
10108 
      oprot.writeFieldEnd()
10109 
    if self.categories is not None:
10110 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10111 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10112 
      for iter143 in self.categories:
10113 
        oprot.writeI64(iter143)
5944 mandeep.dh 10114 
      oprot.writeListEnd()
10115 
      oprot.writeFieldEnd()
10116 
    oprot.writeFieldStop()
10117 
    oprot.writeStructEnd()
10118 
 
10119 
  def validate(self):
10120 
    return
10121 
 
10122 
 
10123 
  def __repr__(self):
10124 
    L = ['%s=%r' % (key, value)
10125 
      for key, value in self.__dict__.iteritems()]
10126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10127 
 
10128 
  def __eq__(self, other):
10129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10130 
 
10131 
  def __ne__(self, other):
10132 
    return not (self == other)
10133 
 
10134 
class getLatestArrivalsCatalogIds_result:
10135 
  """
10136 
  Attributes:
10137 
   - success
10138 
   - cex
10139 
  """
10140 
 
10141 
  thrift_spec = (
10142 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10143 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10144 
  )
10145 
 
10146 
  def __init__(self, success=None, cex=None,):
10147 
    self.success = success
10148 
    self.cex = cex
10149 
 
10150 
  def read(self, iprot):
10151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10153 
      return
10154 
    iprot.readStructBegin()
10155 
    while True:
10156 
      (fname, ftype, fid) = iprot.readFieldBegin()
10157 
      if ftype == TType.STOP:
10158 
        break
10159 
      if fid == 0:
10160 
        if ftype == TType.LIST:
10161 
          self.success = []
8590 kshitij.so 10162 
          (_etype147, _size144) = iprot.readListBegin()
10163 
          for _i148 in xrange(_size144):
10164 
            _elem149 = iprot.readI64();
10165 
            self.success.append(_elem149)
5944 mandeep.dh 10166 
          iprot.readListEnd()
10167 
        else:
10168 
          iprot.skip(ftype)
10169 
      elif fid == 1:
10170 
        if ftype == TType.STRUCT:
10171 
          self.cex = CatalogServiceException()
10172 
          self.cex.read(iprot)
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      else:
10176 
        iprot.skip(ftype)
10177 
      iprot.readFieldEnd()
10178 
    iprot.readStructEnd()
10179 
 
10180 
  def write(self, oprot):
10181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10183 
      return
10184 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10185 
    if self.success is not None:
10186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10187 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10188 
      for iter150 in self.success:
10189 
        oprot.writeI64(iter150)
5944 mandeep.dh 10190 
      oprot.writeListEnd()
10191 
      oprot.writeFieldEnd()
10192 
    if self.cex is not None:
10193 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10194 
      self.cex.write(oprot)
10195 
      oprot.writeFieldEnd()
10196 
    oprot.writeFieldStop()
10197 
    oprot.writeStructEnd()
10198 
 
10199 
  def validate(self):
10200 
    return
10201 
 
10202 
 
10203 
  def __repr__(self):
10204 
    L = ['%s=%r' % (key, value)
10205 
      for key, value in self.__dict__.iteritems()]
10206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10207 
 
10208 
  def __eq__(self, other):
10209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10210 
 
10211 
  def __ne__(self, other):
10212 
    return not (self == other)
10213 
 
10214 
class getLatestArrivalsCount_args:
10215 
 
10216 
  thrift_spec = (
10217 
  )
10218 
 
10219 
  def read(self, iprot):
10220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10222 
      return
10223 
    iprot.readStructBegin()
10224 
    while True:
10225 
      (fname, ftype, fid) = iprot.readFieldBegin()
10226 
      if ftype == TType.STOP:
10227 
        break
10228 
      else:
10229 
        iprot.skip(ftype)
10230 
      iprot.readFieldEnd()
10231 
    iprot.readStructEnd()
10232 
 
10233 
  def write(self, oprot):
10234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10236 
      return
10237 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10238 
    oprot.writeFieldStop()
10239 
    oprot.writeStructEnd()
10240 
 
10241 
  def validate(self):
10242 
    return
10243 
 
10244 
 
10245 
  def __repr__(self):
10246 
    L = ['%s=%r' % (key, value)
10247 
      for key, value in self.__dict__.iteritems()]
10248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10249 
 
10250 
  def __eq__(self, other):
10251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10252 
 
10253 
  def __ne__(self, other):
10254 
    return not (self == other)
10255 
 
10256 
class getLatestArrivalsCount_result:
10257 
  """
10258 
  Attributes:
10259 
   - success
10260 
   - cex
10261 
  """
10262 
 
10263 
  thrift_spec = (
10264 
    (0, TType.I64, 'success', None, None, ), # 0
10265 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10266 
  )
10267 
 
10268 
  def __init__(self, success=None, cex=None,):
10269 
    self.success = success
10270 
    self.cex = cex
10271 
 
10272 
  def read(self, iprot):
10273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10275 
      return
10276 
    iprot.readStructBegin()
10277 
    while True:
10278 
      (fname, ftype, fid) = iprot.readFieldBegin()
10279 
      if ftype == TType.STOP:
10280 
        break
10281 
      if fid == 0:
10282 
        if ftype == TType.I64:
10283 
          self.success = iprot.readI64();
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      elif fid == 1:
10287 
        if ftype == TType.STRUCT:
10288 
          self.cex = CatalogServiceException()
10289 
          self.cex.read(iprot)
10290 
        else:
10291 
          iprot.skip(ftype)
10292 
      else:
10293 
        iprot.skip(ftype)
10294 
      iprot.readFieldEnd()
10295 
    iprot.readStructEnd()
10296 
 
10297 
  def write(self, oprot):
10298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10300 
      return
10301 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10302 
    if self.success is not None:
10303 
      oprot.writeFieldBegin('success', TType.I64, 0)
10304 
      oprot.writeI64(self.success)
10305 
      oprot.writeFieldEnd()
10306 
    if self.cex is not None:
10307 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10308 
      self.cex.write(oprot)
10309 
      oprot.writeFieldEnd()
10310 
    oprot.writeFieldStop()
10311 
    oprot.writeStructEnd()
10312 
 
10313 
  def validate(self):
10314 
    return
10315 
 
10316 
 
10317 
  def __repr__(self):
10318 
    L = ['%s=%r' % (key, value)
10319 
      for key, value in self.__dict__.iteritems()]
10320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10321 
 
10322 
  def __eq__(self, other):
10323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10324 
 
10325 
  def __ne__(self, other):
10326 
    return not (self == other)
10327 
 
10328 
class generateNewEntityID_args:
10329 
 
10330 
  thrift_spec = (
10331 
  )
10332 
 
10333 
  def read(self, iprot):
10334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10336 
      return
10337 
    iprot.readStructBegin()
10338 
    while True:
10339 
      (fname, ftype, fid) = iprot.readFieldBegin()
10340 
      if ftype == TType.STOP:
10341 
        break
10342 
      else:
10343 
        iprot.skip(ftype)
10344 
      iprot.readFieldEnd()
10345 
    iprot.readStructEnd()
10346 
 
10347 
  def write(self, oprot):
10348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10350 
      return
10351 
    oprot.writeStructBegin('generateNewEntityID_args')
10352 
    oprot.writeFieldStop()
10353 
    oprot.writeStructEnd()
10354 
 
10355 
  def validate(self):
10356 
    return
10357 
 
10358 
 
10359 
  def __repr__(self):
10360 
    L = ['%s=%r' % (key, value)
10361 
      for key, value in self.__dict__.iteritems()]
10362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10363 
 
10364 
  def __eq__(self, other):
10365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10366 
 
10367 
  def __ne__(self, other):
10368 
    return not (self == other)
10369 
 
10370 
class generateNewEntityID_result:
10371 
  """
10372 
  Attributes:
10373 
   - success
10374 
  """
10375 
 
10376 
  thrift_spec = (
10377 
    (0, TType.I64, 'success', None, None, ), # 0
10378 
  )
10379 
 
10380 
  def __init__(self, success=None,):
10381 
    self.success = success
10382 
 
10383 
  def read(self, iprot):
10384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10386 
      return
10387 
    iprot.readStructBegin()
10388 
    while True:
10389 
      (fname, ftype, fid) = iprot.readFieldBegin()
10390 
      if ftype == TType.STOP:
10391 
        break
10392 
      if fid == 0:
10393 
        if ftype == TType.I64:
10394 
          self.success = iprot.readI64();
10395 
        else:
10396 
          iprot.skip(ftype)
10397 
      else:
10398 
        iprot.skip(ftype)
10399 
      iprot.readFieldEnd()
10400 
    iprot.readStructEnd()
10401 
 
10402 
  def write(self, oprot):
10403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10405 
      return
10406 
    oprot.writeStructBegin('generateNewEntityID_result')
10407 
    if self.success is not None:
10408 
      oprot.writeFieldBegin('success', TType.I64, 0)
10409 
      oprot.writeI64(self.success)
10410 
      oprot.writeFieldEnd()
10411 
    oprot.writeFieldStop()
10412 
    oprot.writeStructEnd()
10413 
 
10414 
  def validate(self):
10415 
    return
10416 
 
10417 
 
10418 
  def __repr__(self):
10419 
    L = ['%s=%r' % (key, value)
10420 
      for key, value in self.__dict__.iteritems()]
10421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10422 
 
10423 
  def __eq__(self, other):
10424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10425 
 
10426 
  def __ne__(self, other):
10427 
    return not (self == other)
10428 
 
10429 
class addCategory_args:
10430 
  """
10431 
  Attributes:
10432 
   - category
10433 
  """
10434 
 
10435 
  thrift_spec = (
10436 
    None, # 0
10437 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10438 
  )
10439 
 
10440 
  def __init__(self, category=None,):
10441 
    self.category = category
10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      if fid == 1:
10453 
        if ftype == TType.STRUCT:
10454 
          self.category = Category()
10455 
          self.category.read(iprot)
10456 
        else:
10457 
          iprot.skip(ftype)
10458 
      else:
10459 
        iprot.skip(ftype)
10460 
      iprot.readFieldEnd()
10461 
    iprot.readStructEnd()
10462 
 
10463 
  def write(self, oprot):
10464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10466 
      return
10467 
    oprot.writeStructBegin('addCategory_args')
10468 
    if self.category is not None:
10469 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10470 
      self.category.write(oprot)
10471 
      oprot.writeFieldEnd()
10472 
    oprot.writeFieldStop()
10473 
    oprot.writeStructEnd()
10474 
 
10475 
  def validate(self):
10476 
    return
10477 
 
10478 
 
10479 
  def __repr__(self):
10480 
    L = ['%s=%r' % (key, value)
10481 
      for key, value in self.__dict__.iteritems()]
10482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10483 
 
10484 
  def __eq__(self, other):
10485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10486 
 
10487 
  def __ne__(self, other):
10488 
    return not (self == other)
10489 
 
10490 
class addCategory_result:
10491 
  """
10492 
  Attributes:
10493 
   - success
10494 
  """
10495 
 
10496 
  thrift_spec = (
10497 
    (0, TType.BOOL, 'success', None, None, ), # 0
10498 
  )
10499 
 
10500 
  def __init__(self, success=None,):
10501 
    self.success = success
10502 
 
10503 
  def read(self, iprot):
10504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10506 
      return
10507 
    iprot.readStructBegin()
10508 
    while True:
10509 
      (fname, ftype, fid) = iprot.readFieldBegin()
10510 
      if ftype == TType.STOP:
10511 
        break
10512 
      if fid == 0:
10513 
        if ftype == TType.BOOL:
10514 
          self.success = iprot.readBool();
10515 
        else:
10516 
          iprot.skip(ftype)
10517 
      else:
10518 
        iprot.skip(ftype)
10519 
      iprot.readFieldEnd()
10520 
    iprot.readStructEnd()
10521 
 
10522 
  def write(self, oprot):
10523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10525 
      return
10526 
    oprot.writeStructBegin('addCategory_result')
10527 
    if self.success is not None:
10528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10529 
      oprot.writeBool(self.success)
10530 
      oprot.writeFieldEnd()
10531 
    oprot.writeFieldStop()
10532 
    oprot.writeStructEnd()
10533 
 
10534 
  def validate(self):
10535 
    return
10536 
 
10537 
 
10538 
  def __repr__(self):
10539 
    L = ['%s=%r' % (key, value)
10540 
      for key, value in self.__dict__.iteritems()]
10541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10542 
 
10543 
  def __eq__(self, other):
10544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10545 
 
10546 
  def __ne__(self, other):
10547 
    return not (self == other)
10548 
 
10549 
class getCategory_args:
10550 
  """
10551 
  Attributes:
10552 
   - id
10553 
  """
10554 
 
10555 
  thrift_spec = (
10556 
    None, # 0
10557 
    (1, TType.I64, 'id', None, None, ), # 1
10558 
  )
10559 
 
10560 
  def __init__(self, id=None,):
10561 
    self.id = id
10562 
 
10563 
  def read(self, iprot):
10564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10566 
      return
10567 
    iprot.readStructBegin()
10568 
    while True:
10569 
      (fname, ftype, fid) = iprot.readFieldBegin()
10570 
      if ftype == TType.STOP:
10571 
        break
10572 
      if fid == 1:
10573 
        if ftype == TType.I64:
10574 
          self.id = iprot.readI64();
10575 
        else:
10576 
          iprot.skip(ftype)
10577 
      else:
10578 
        iprot.skip(ftype)
10579 
      iprot.readFieldEnd()
10580 
    iprot.readStructEnd()
10581 
 
10582 
  def write(self, oprot):
10583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10585 
      return
10586 
    oprot.writeStructBegin('getCategory_args')
10587 
    if self.id is not None:
10588 
      oprot.writeFieldBegin('id', TType.I64, 1)
10589 
      oprot.writeI64(self.id)
10590 
      oprot.writeFieldEnd()
10591 
    oprot.writeFieldStop()
10592 
    oprot.writeStructEnd()
10593 
 
10594 
  def validate(self):
10595 
    return
10596 
 
10597 
 
10598 
  def __repr__(self):
10599 
    L = ['%s=%r' % (key, value)
10600 
      for key, value in self.__dict__.iteritems()]
10601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10602 
 
10603 
  def __eq__(self, other):
10604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10605 
 
10606 
  def __ne__(self, other):
10607 
    return not (self == other)
10608 
 
10609 
class getCategory_result:
10610 
  """
10611 
  Attributes:
10612 
   - success
10613 
  """
10614 
 
10615 
  thrift_spec = (
10616 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10617 
  )
10618 
 
10619 
  def __init__(self, success=None,):
10620 
    self.success = success
10621 
 
10622 
  def read(self, iprot):
10623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10625 
      return
10626 
    iprot.readStructBegin()
10627 
    while True:
10628 
      (fname, ftype, fid) = iprot.readFieldBegin()
10629 
      if ftype == TType.STOP:
10630 
        break
10631 
      if fid == 0:
10632 
        if ftype == TType.STRUCT:
10633 
          self.success = Category()
10634 
          self.success.read(iprot)
10635 
        else:
10636 
          iprot.skip(ftype)
10637 
      else:
10638 
        iprot.skip(ftype)
10639 
      iprot.readFieldEnd()
10640 
    iprot.readStructEnd()
10641 
 
10642 
  def write(self, oprot):
10643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10645 
      return
10646 
    oprot.writeStructBegin('getCategory_result')
10647 
    if self.success is not None:
10648 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10649 
      self.success.write(oprot)
10650 
      oprot.writeFieldEnd()
10651 
    oprot.writeFieldStop()
10652 
    oprot.writeStructEnd()
10653 
 
10654 
  def validate(self):
10655 
    return
10656 
 
10657 
 
10658 
  def __repr__(self):
10659 
    L = ['%s=%r' % (key, value)
10660 
      for key, value in self.__dict__.iteritems()]
10661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10662 
 
10663 
  def __eq__(self, other):
10664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10665 
 
10666 
  def __ne__(self, other):
10667 
    return not (self == other)
10668 
 
10669 
class getAllCategories_args:
10670 
 
10671 
  thrift_spec = (
10672 
  )
10673 
 
10674 
  def read(self, iprot):
10675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10677 
      return
10678 
    iprot.readStructBegin()
10679 
    while True:
10680 
      (fname, ftype, fid) = iprot.readFieldBegin()
10681 
      if ftype == TType.STOP:
10682 
        break
10683 
      else:
10684 
        iprot.skip(ftype)
10685 
      iprot.readFieldEnd()
10686 
    iprot.readStructEnd()
10687 
 
10688 
  def write(self, oprot):
10689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10691 
      return
10692 
    oprot.writeStructBegin('getAllCategories_args')
10693 
    oprot.writeFieldStop()
10694 
    oprot.writeStructEnd()
10695 
 
10696 
  def validate(self):
10697 
    return
10698 
 
10699 
 
10700 
  def __repr__(self):
10701 
    L = ['%s=%r' % (key, value)
10702 
      for key, value in self.__dict__.iteritems()]
10703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10704 
 
10705 
  def __eq__(self, other):
10706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10707 
 
10708 
  def __ne__(self, other):
10709 
    return not (self == other)
10710 
 
10711 
class getAllCategories_result:
10712 
  """
10713 
  Attributes:
10714 
   - success
10715 
  """
10716 
 
10717 
  thrift_spec = (
10718 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10719 
  )
10720 
 
10721 
  def __init__(self, success=None,):
10722 
    self.success = success
10723 
 
10724 
  def read(self, iprot):
10725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10727 
      return
10728 
    iprot.readStructBegin()
10729 
    while True:
10730 
      (fname, ftype, fid) = iprot.readFieldBegin()
10731 
      if ftype == TType.STOP:
10732 
        break
10733 
      if fid == 0:
10734 
        if ftype == TType.LIST:
10735 
          self.success = []
8590 kshitij.so 10736 
          (_etype154, _size151) = iprot.readListBegin()
10737 
          for _i155 in xrange(_size151):
10738 
            _elem156 = Category()
10739 
            _elem156.read(iprot)
10740 
            self.success.append(_elem156)
5944 mandeep.dh 10741 
          iprot.readListEnd()
10742 
        else:
10743 
          iprot.skip(ftype)
10744 
      else:
10745 
        iprot.skip(ftype)
10746 
      iprot.readFieldEnd()
10747 
    iprot.readStructEnd()
10748 
 
10749 
  def write(self, oprot):
10750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10752 
      return
10753 
    oprot.writeStructBegin('getAllCategories_result')
10754 
    if self.success is not None:
10755 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10756 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10757 
      for iter157 in self.success:
10758 
        iter157.write(oprot)
5944 mandeep.dh 10759 
      oprot.writeListEnd()
10760 
      oprot.writeFieldEnd()
10761 
    oprot.writeFieldStop()
10762 
    oprot.writeStructEnd()
10763 
 
10764 
  def validate(self):
10765 
    return
10766 
 
10767 
 
10768 
  def __repr__(self):
10769 
    L = ['%s=%r' % (key, value)
10770 
      for key, value in self.__dict__.iteritems()]
10771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10772 
 
10773 
  def __eq__(self, other):
10774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10775 
 
10776 
  def __ne__(self, other):
10777 
    return not (self == other)
10778 
 
10779 
class getAllSimilarItems_args:
10780 
  """
10781 
  Attributes:
10782 
   - itemId
10783 
  """
10784 
 
10785 
  thrift_spec = (
10786 
    None, # 0
10787 
    (1, TType.I64, 'itemId', None, None, ), # 1
10788 
  )
10789 
 
10790 
  def __init__(self, itemId=None,):
10791 
    self.itemId = itemId
10792 
 
10793 
  def read(self, iprot):
10794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10796 
      return
10797 
    iprot.readStructBegin()
10798 
    while True:
10799 
      (fname, ftype, fid) = iprot.readFieldBegin()
10800 
      if ftype == TType.STOP:
10801 
        break
10802 
      if fid == 1:
10803 
        if ftype == TType.I64:
10804 
          self.itemId = iprot.readI64();
10805 
        else:
10806 
          iprot.skip(ftype)
10807 
      else:
10808 
        iprot.skip(ftype)
10809 
      iprot.readFieldEnd()
10810 
    iprot.readStructEnd()
10811 
 
10812 
  def write(self, oprot):
10813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10815 
      return
10816 
    oprot.writeStructBegin('getAllSimilarItems_args')
10817 
    if self.itemId is not None:
10818 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10819 
      oprot.writeI64(self.itemId)
10820 
      oprot.writeFieldEnd()
10821 
    oprot.writeFieldStop()
10822 
    oprot.writeStructEnd()
10823 
 
10824 
  def validate(self):
10825 
    return
10826 
 
10827 
 
10828 
  def __repr__(self):
10829 
    L = ['%s=%r' % (key, value)
10830 
      for key, value in self.__dict__.iteritems()]
10831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10832 
 
10833 
  def __eq__(self, other):
10834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10835 
 
10836 
  def __ne__(self, other):
10837 
    return not (self == other)
10838 
 
10839 
class getAllSimilarItems_result:
10840 
  """
10841 
  Attributes:
10842 
   - success
10843 
  """
10844 
 
10845 
  thrift_spec = (
10846 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10847 
  )
10848 
 
10849 
  def __init__(self, success=None,):
10850 
    self.success = success
10851 
 
10852 
  def read(self, iprot):
10853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10855 
      return
10856 
    iprot.readStructBegin()
10857 
    while True:
10858 
      (fname, ftype, fid) = iprot.readFieldBegin()
10859 
      if ftype == TType.STOP:
10860 
        break
10861 
      if fid == 0:
10862 
        if ftype == TType.LIST:
10863 
          self.success = []
8590 kshitij.so 10864 
          (_etype161, _size158) = iprot.readListBegin()
10865 
          for _i162 in xrange(_size158):
10866 
            _elem163 = Item()
10867 
            _elem163.read(iprot)
10868 
            self.success.append(_elem163)
5944 mandeep.dh 10869 
          iprot.readListEnd()
10870 
        else:
10871 
          iprot.skip(ftype)
10872 
      else:
10873 
        iprot.skip(ftype)
10874 
      iprot.readFieldEnd()
10875 
    iprot.readStructEnd()
10876 
 
10877 
  def write(self, oprot):
10878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10880 
      return
10881 
    oprot.writeStructBegin('getAllSimilarItems_result')
10882 
    if self.success is not None:
10883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10885 
      for iter164 in self.success:
10886 
        iter164.write(oprot)
5944 mandeep.dh 10887 
      oprot.writeListEnd()
10888 
      oprot.writeFieldEnd()
10889 
    oprot.writeFieldStop()
10890 
    oprot.writeStructEnd()
10891 
 
10892 
  def validate(self):
10893 
    return
10894 
 
10895 
 
10896 
  def __repr__(self):
10897 
    L = ['%s=%r' % (key, value)
10898 
      for key, value in self.__dict__.iteritems()]
10899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10900 
 
10901 
  def __eq__(self, other):
10902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10903 
 
10904 
  def __ne__(self, other):
10905 
    return not (self == other)
10906 
 
10907 
class addSimilarItem_args:
10908 
  """
10909 
  Attributes:
10910 
   - itemId
10911 
   - catalogItemId
10912 
  """
10913 
 
10914 
  thrift_spec = (
10915 
    None, # 0
10916 
    (1, TType.I64, 'itemId', None, None, ), # 1
10917 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10918 
  )
10919 
 
10920 
  def __init__(self, itemId=None, catalogItemId=None,):
10921 
    self.itemId = itemId
10922 
    self.catalogItemId = catalogItemId
10923 
 
10924 
  def read(self, iprot):
10925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10927 
      return
10928 
    iprot.readStructBegin()
10929 
    while True:
10930 
      (fname, ftype, fid) = iprot.readFieldBegin()
10931 
      if ftype == TType.STOP:
10932 
        break
10933 
      if fid == 1:
10934 
        if ftype == TType.I64:
10935 
          self.itemId = iprot.readI64();
10936 
        else:
10937 
          iprot.skip(ftype)
10938 
      elif fid == 2:
10939 
        if ftype == TType.I64:
10940 
          self.catalogItemId = iprot.readI64();
10941 
        else:
10942 
          iprot.skip(ftype)
10943 
      else:
10944 
        iprot.skip(ftype)
10945 
      iprot.readFieldEnd()
10946 
    iprot.readStructEnd()
10947 
 
10948 
  def write(self, oprot):
10949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10951 
      return
10952 
    oprot.writeStructBegin('addSimilarItem_args')
10953 
    if self.itemId is not None:
10954 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10955 
      oprot.writeI64(self.itemId)
10956 
      oprot.writeFieldEnd()
10957 
    if self.catalogItemId is not None:
10958 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10959 
      oprot.writeI64(self.catalogItemId)
10960 
      oprot.writeFieldEnd()
10961 
    oprot.writeFieldStop()
10962 
    oprot.writeStructEnd()
10963 
 
10964 
  def validate(self):
10965 
    return
10966 
 
10967 
 
10968 
  def __repr__(self):
10969 
    L = ['%s=%r' % (key, value)
10970 
      for key, value in self.__dict__.iteritems()]
10971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10972 
 
10973 
  def __eq__(self, other):
10974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10975 
 
10976 
  def __ne__(self, other):
10977 
    return not (self == other)
10978 
 
10979 
class addSimilarItem_result:
10980 
  """
10981 
  Attributes:
10982 
   - success
10983 
   - cex
10984 
  """
10985 
 
10986 
  thrift_spec = (
10987 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10988 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10989 
  )
10990 
 
10991 
  def __init__(self, success=None, cex=None,):
10992 
    self.success = success
10993 
    self.cex = cex
10994 
 
10995 
  def read(self, iprot):
10996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10998 
      return
10999 
    iprot.readStructBegin()
11000 
    while True:
11001 
      (fname, ftype, fid) = iprot.readFieldBegin()
11002 
      if ftype == TType.STOP:
11003 
        break
11004 
      if fid == 0:
11005 
        if ftype == TType.STRUCT:
11006 
          self.success = Item()
11007 
          self.success.read(iprot)
11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      elif fid == 1:
11011 
        if ftype == TType.STRUCT:
11012 
          self.cex = CatalogServiceException()
11013 
          self.cex.read(iprot)
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      else:
11017 
        iprot.skip(ftype)
11018 
      iprot.readFieldEnd()
11019 
    iprot.readStructEnd()
11020 
 
11021 
  def write(self, oprot):
11022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11024 
      return
11025 
    oprot.writeStructBegin('addSimilarItem_result')
11026 
    if self.success is not None:
11027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11028 
      self.success.write(oprot)
11029 
      oprot.writeFieldEnd()
11030 
    if self.cex is not None:
11031 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11032 
      self.cex.write(oprot)
11033 
      oprot.writeFieldEnd()
11034 
    oprot.writeFieldStop()
11035 
    oprot.writeStructEnd()
11036 
 
11037 
  def validate(self):
11038 
    return
11039 
 
11040 
 
11041 
  def __repr__(self):
11042 
    L = ['%s=%r' % (key, value)
11043 
      for key, value in self.__dict__.iteritems()]
11044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11045 
 
11046 
  def __eq__(self, other):
11047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11048 
 
11049 
  def __ne__(self, other):
11050 
    return not (self == other)
11051 
 
6512 kshitij.so 11052 
class addTag_args:
11053 
  """
11054 
  Attributes:
11055 
   - displayName
11056 
   - itemId
11057 
  """
11058 
 
11059 
  thrift_spec = (
11060 
    None, # 0
11061 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11062 
    (2, TType.I64, 'itemId', None, None, ), # 2
11063 
  )
11064 
 
11065 
  def __init__(self, displayName=None, itemId=None,):
11066 
    self.displayName = displayName
11067 
    self.itemId = itemId
11068 
 
11069 
  def read(self, iprot):
11070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11072 
      return
11073 
    iprot.readStructBegin()
11074 
    while True:
11075 
      (fname, ftype, fid) = iprot.readFieldBegin()
11076 
      if ftype == TType.STOP:
11077 
        break
11078 
      if fid == 1:
11079 
        if ftype == TType.STRING:
11080 
          self.displayName = iprot.readString();
11081 
        else:
11082 
          iprot.skip(ftype)
11083 
      elif fid == 2:
11084 
        if ftype == TType.I64:
11085 
          self.itemId = iprot.readI64();
11086 
        else:
11087 
          iprot.skip(ftype)
11088 
      else:
11089 
        iprot.skip(ftype)
11090 
      iprot.readFieldEnd()
11091 
    iprot.readStructEnd()
11092 
 
11093 
  def write(self, oprot):
11094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11096 
      return
11097 
    oprot.writeStructBegin('addTag_args')
11098 
    if self.displayName is not None:
11099 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11100 
      oprot.writeString(self.displayName)
11101 
      oprot.writeFieldEnd()
11102 
    if self.itemId is not None:
11103 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11104 
      oprot.writeI64(self.itemId)
11105 
      oprot.writeFieldEnd()
11106 
    oprot.writeFieldStop()
11107 
    oprot.writeStructEnd()
11108 
 
11109 
  def validate(self):
11110 
    return
11111 
 
11112 
 
11113 
  def __repr__(self):
11114 
    L = ['%s=%r' % (key, value)
11115 
      for key, value in self.__dict__.iteritems()]
11116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11117 
 
11118 
  def __eq__(self, other):
11119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11120 
 
11121 
  def __ne__(self, other):
11122 
    return not (self == other)
11123 
 
11124 
class addTag_result:
11125 
  """
11126 
  Attributes:
11127 
   - success
11128 
  """
11129 
 
11130 
  thrift_spec = (
11131 
    (0, TType.BOOL, 'success', None, None, ), # 0
11132 
  )
11133 
 
11134 
  def __init__(self, success=None,):
11135 
    self.success = success
11136 
 
11137 
  def read(self, iprot):
11138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11140 
      return
11141 
    iprot.readStructBegin()
11142 
    while True:
11143 
      (fname, ftype, fid) = iprot.readFieldBegin()
11144 
      if ftype == TType.STOP:
11145 
        break
11146 
      if fid == 0:
11147 
        if ftype == TType.BOOL:
11148 
          self.success = iprot.readBool();
11149 
        else:
11150 
          iprot.skip(ftype)
11151 
      else:
11152 
        iprot.skip(ftype)
11153 
      iprot.readFieldEnd()
11154 
    iprot.readStructEnd()
11155 
 
11156 
  def write(self, oprot):
11157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11159 
      return
11160 
    oprot.writeStructBegin('addTag_result')
11161 
    if self.success is not None:
11162 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11163 
      oprot.writeBool(self.success)
11164 
      oprot.writeFieldEnd()
11165 
    oprot.writeFieldStop()
11166 
    oprot.writeStructEnd()
11167 
 
11168 
  def validate(self):
11169 
    return
11170 
 
11171 
 
11172 
  def __repr__(self):
11173 
    L = ['%s=%r' % (key, value)
11174 
      for key, value in self.__dict__.iteritems()]
11175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11176 
 
11177 
  def __eq__(self, other):
11178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11179 
 
11180 
  def __ne__(self, other):
11181 
    return not (self == other)
11182 
 
11183 
class deleteEntityTag_args:
11184 
  """
11185 
  Attributes:
11186 
   - displayName
11187 
   - itemId
11188 
  """
11189 
 
11190 
  thrift_spec = (
11191 
    None, # 0
11192 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11193 
    (2, TType.I64, 'itemId', None, None, ), # 2
11194 
  )
11195 
 
11196 
  def __init__(self, displayName=None, itemId=None,):
11197 
    self.displayName = displayName
11198 
    self.itemId = itemId
11199 
 
11200 
  def read(self, iprot):
11201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11203 
      return
11204 
    iprot.readStructBegin()
11205 
    while True:
11206 
      (fname, ftype, fid) = iprot.readFieldBegin()
11207 
      if ftype == TType.STOP:
11208 
        break
11209 
      if fid == 1:
11210 
        if ftype == TType.STRING:
11211 
          self.displayName = iprot.readString();
11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      elif fid == 2:
11215 
        if ftype == TType.I64:
11216 
          self.itemId = iprot.readI64();
11217 
        else:
11218 
          iprot.skip(ftype)
11219 
      else:
11220 
        iprot.skip(ftype)
11221 
      iprot.readFieldEnd()
11222 
    iprot.readStructEnd()
11223 
 
11224 
  def write(self, oprot):
11225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11227 
      return
11228 
    oprot.writeStructBegin('deleteEntityTag_args')
11229 
    if self.displayName is not None:
11230 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11231 
      oprot.writeString(self.displayName)
11232 
      oprot.writeFieldEnd()
11233 
    if self.itemId is not None:
11234 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11235 
      oprot.writeI64(self.itemId)
11236 
      oprot.writeFieldEnd()
11237 
    oprot.writeFieldStop()
11238 
    oprot.writeStructEnd()
11239 
 
11240 
  def validate(self):
11241 
    return
11242 
 
11243 
 
11244 
  def __repr__(self):
11245 
    L = ['%s=%r' % (key, value)
11246 
      for key, value in self.__dict__.iteritems()]
11247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11248 
 
11249 
  def __eq__(self, other):
11250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11251 
 
11252 
  def __ne__(self, other):
11253 
    return not (self == other)
11254 
 
11255 
class deleteEntityTag_result:
11256 
  """
11257 
  Attributes:
11258 
   - success
11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    (0, TType.BOOL, 'success', None, None, ), # 0
11263 
  )
11264 
 
11265 
  def __init__(self, success=None,):
11266 
    self.success = success
11267 
 
11268 
  def read(self, iprot):
11269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11271 
      return
11272 
    iprot.readStructBegin()
11273 
    while True:
11274 
      (fname, ftype, fid) = iprot.readFieldBegin()
11275 
      if ftype == TType.STOP:
11276 
        break
11277 
      if fid == 0:
11278 
        if ftype == TType.BOOL:
11279 
          self.success = iprot.readBool();
11280 
        else:
11281 
          iprot.skip(ftype)
11282 
      else:
11283 
        iprot.skip(ftype)
11284 
      iprot.readFieldEnd()
11285 
    iprot.readStructEnd()
11286 
 
11287 
  def write(self, oprot):
11288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11290 
      return
11291 
    oprot.writeStructBegin('deleteEntityTag_result')
11292 
    if self.success is not None:
11293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11294 
      oprot.writeBool(self.success)
11295 
      oprot.writeFieldEnd()
11296 
    oprot.writeFieldStop()
11297 
    oprot.writeStructEnd()
11298 
 
11299 
  def validate(self):
11300 
    return
11301 
 
11302 
 
11303 
  def __repr__(self):
11304 
    L = ['%s=%r' % (key, value)
11305 
      for key, value in self.__dict__.iteritems()]
11306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11307 
 
11308 
  def __eq__(self, other):
11309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11310 
 
11311 
  def __ne__(self, other):
11312 
    return not (self == other)
11313 
 
11314 
class deleteTag_args:
11315 
  """
11316 
  Attributes:
11317 
   - displayName
11318 
  """
11319 
 
11320 
  thrift_spec = (
11321 
    None, # 0
11322 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11323 
  )
11324 
 
11325 
  def __init__(self, displayName=None,):
11326 
    self.displayName = displayName
11327 
 
11328 
  def read(self, iprot):
11329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11331 
      return
11332 
    iprot.readStructBegin()
11333 
    while True:
11334 
      (fname, ftype, fid) = iprot.readFieldBegin()
11335 
      if ftype == TType.STOP:
11336 
        break
11337 
      if fid == 1:
11338 
        if ftype == TType.STRING:
11339 
          self.displayName = iprot.readString();
11340 
        else:
11341 
          iprot.skip(ftype)
11342 
      else:
11343 
        iprot.skip(ftype)
11344 
      iprot.readFieldEnd()
11345 
    iprot.readStructEnd()
11346 
 
11347 
  def write(self, oprot):
11348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11350 
      return
11351 
    oprot.writeStructBegin('deleteTag_args')
11352 
    if self.displayName is not None:
11353 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11354 
      oprot.writeString(self.displayName)
11355 
      oprot.writeFieldEnd()
11356 
    oprot.writeFieldStop()
11357 
    oprot.writeStructEnd()
11358 
 
11359 
  def validate(self):
11360 
    return
11361 
 
11362 
 
11363 
  def __repr__(self):
11364 
    L = ['%s=%r' % (key, value)
11365 
      for key, value in self.__dict__.iteritems()]
11366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11367 
 
11368 
  def __eq__(self, other):
11369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11370 
 
11371 
  def __ne__(self, other):
11372 
    return not (self == other)
11373 
 
11374 
class deleteTag_result:
11375 
  """
11376 
  Attributes:
11377 
   - success
11378 
  """
11379 
 
11380 
  thrift_spec = (
11381 
    (0, TType.BOOL, 'success', None, None, ), # 0
11382 
  )
11383 
 
11384 
  def __init__(self, success=None,):
11385 
    self.success = success
11386 
 
11387 
  def read(self, iprot):
11388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11390 
      return
11391 
    iprot.readStructBegin()
11392 
    while True:
11393 
      (fname, ftype, fid) = iprot.readFieldBegin()
11394 
      if ftype == TType.STOP:
11395 
        break
11396 
      if fid == 0:
11397 
        if ftype == TType.BOOL:
11398 
          self.success = iprot.readBool();
11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
11410 
    oprot.writeStructBegin('deleteTag_result')
11411 
    if self.success is not None:
11412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11413 
      oprot.writeBool(self.success)
11414 
      oprot.writeFieldEnd()
11415 
    oprot.writeFieldStop()
11416 
    oprot.writeStructEnd()
11417 
 
11418 
  def validate(self):
11419 
    return
11420 
 
11421 
 
11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
11433 
class getAllTags_args:
11434 
 
11435 
  thrift_spec = (
11436 
  )
11437 
 
11438 
  def read(self, iprot):
11439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11441 
      return
11442 
    iprot.readStructBegin()
11443 
    while True:
11444 
      (fname, ftype, fid) = iprot.readFieldBegin()
11445 
      if ftype == TType.STOP:
11446 
        break
11447 
      else:
11448 
        iprot.skip(ftype)
11449 
      iprot.readFieldEnd()
11450 
    iprot.readStructEnd()
11451 
 
11452 
  def write(self, oprot):
11453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11455 
      return
11456 
    oprot.writeStructBegin('getAllTags_args')
11457 
    oprot.writeFieldStop()
11458 
    oprot.writeStructEnd()
11459 
 
11460 
  def validate(self):
11461 
    return
11462 
 
11463 
 
11464 
  def __repr__(self):
11465 
    L = ['%s=%r' % (key, value)
11466 
      for key, value in self.__dict__.iteritems()]
11467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11468 
 
11469 
  def __eq__(self, other):
11470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11471 
 
11472 
  def __ne__(self, other):
11473 
    return not (self == other)
11474 
 
11475 
class getAllTags_result:
11476 
  """
11477 
  Attributes:
11478 
   - success
11479 
  """
11480 
 
11481 
  thrift_spec = (
11482 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11483 
  )
11484 
 
11485 
  def __init__(self, success=None,):
11486 
    self.success = success
11487 
 
11488 
  def read(self, iprot):
11489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11491 
      return
11492 
    iprot.readStructBegin()
11493 
    while True:
11494 
      (fname, ftype, fid) = iprot.readFieldBegin()
11495 
      if ftype == TType.STOP:
11496 
        break
11497 
      if fid == 0:
11498 
        if ftype == TType.LIST:
11499 
          self.success = []
8590 kshitij.so 11500 
          (_etype168, _size165) = iprot.readListBegin()
11501 
          for _i169 in xrange(_size165):
11502 
            _elem170 = iprot.readString();
11503 
            self.success.append(_elem170)
6512 kshitij.so 11504 
          iprot.readListEnd()
11505 
        else:
11506 
          iprot.skip(ftype)
11507 
      else:
11508 
        iprot.skip(ftype)
11509 
      iprot.readFieldEnd()
11510 
    iprot.readStructEnd()
11511 
 
11512 
  def write(self, oprot):
11513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11515 
      return
11516 
    oprot.writeStructBegin('getAllTags_result')
11517 
    if self.success is not None:
11518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11519 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11520 
      for iter171 in self.success:
11521 
        oprot.writeString(iter171)
6512 kshitij.so 11522 
      oprot.writeListEnd()
11523 
      oprot.writeFieldEnd()
11524 
    oprot.writeFieldStop()
11525 
    oprot.writeStructEnd()
11526 
 
11527 
  def validate(self):
11528 
    return
11529 
 
11530 
 
11531 
  def __repr__(self):
11532 
    L = ['%s=%r' % (key, value)
11533 
      for key, value in self.__dict__.iteritems()]
11534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11535 
 
11536 
  def __eq__(self, other):
11537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11538 
 
11539 
  def __ne__(self, other):
11540 
    return not (self == other)
11541 
 
11542 
class getAllEntitiesByTagName_args:
11543 
  """
11544 
  Attributes:
11545 
   - displayName
11546 
  """
11547 
 
11548 
  thrift_spec = (
11549 
    None, # 0
11550 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, displayName=None,):
11554 
    self.displayName = displayName
11555 
 
11556 
  def read(self, iprot):
11557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11559 
      return
11560 
    iprot.readStructBegin()
11561 
    while True:
11562 
      (fname, ftype, fid) = iprot.readFieldBegin()
11563 
      if ftype == TType.STOP:
11564 
        break
11565 
      if fid == 1:
11566 
        if ftype == TType.STRING:
11567 
          self.displayName = iprot.readString();
11568 
        else:
11569 
          iprot.skip(ftype)
11570 
      else:
11571 
        iprot.skip(ftype)
11572 
      iprot.readFieldEnd()
11573 
    iprot.readStructEnd()
11574 
 
11575 
  def write(self, oprot):
11576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11578 
      return
11579 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11580 
    if self.displayName is not None:
11581 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11582 
      oprot.writeString(self.displayName)
11583 
      oprot.writeFieldEnd()
11584 
    oprot.writeFieldStop()
11585 
    oprot.writeStructEnd()
11586 
 
11587 
  def validate(self):
11588 
    return
11589 
 
11590 
 
11591 
  def __repr__(self):
11592 
    L = ['%s=%r' % (key, value)
11593 
      for key, value in self.__dict__.iteritems()]
11594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11595 
 
11596 
  def __eq__(self, other):
11597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11598 
 
11599 
  def __ne__(self, other):
11600 
    return not (self == other)
11601 
 
11602 
class getAllEntitiesByTagName_result:
11603 
  """
11604 
  Attributes:
11605 
   - success
11606 
  """
11607 
 
11608 
  thrift_spec = (
11609 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11610 
  )
11611 
 
11612 
  def __init__(self, success=None,):
11613 
    self.success = success
11614 
 
11615 
  def read(self, iprot):
11616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11618 
      return
11619 
    iprot.readStructBegin()
11620 
    while True:
11621 
      (fname, ftype, fid) = iprot.readFieldBegin()
11622 
      if ftype == TType.STOP:
11623 
        break
11624 
      if fid == 0:
11625 
        if ftype == TType.LIST:
11626 
          self.success = []
8590 kshitij.so 11627 
          (_etype175, _size172) = iprot.readListBegin()
11628 
          for _i176 in xrange(_size172):
11629 
            _elem177 = iprot.readI64();
11630 
            self.success.append(_elem177)
6512 kshitij.so 11631 
          iprot.readListEnd()
11632 
        else:
11633 
          iprot.skip(ftype)
11634 
      else:
11635 
        iprot.skip(ftype)
11636 
      iprot.readFieldEnd()
11637 
    iprot.readStructEnd()
11638 
 
11639 
  def write(self, oprot):
11640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11642 
      return
11643 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11644 
    if self.success is not None:
11645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11646 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11647 
      for iter178 in self.success:
11648 
        oprot.writeI64(iter178)
6512 kshitij.so 11649 
      oprot.writeListEnd()
11650 
      oprot.writeFieldEnd()
11651 
    oprot.writeFieldStop()
11652 
    oprot.writeStructEnd()
11653 
 
11654 
  def validate(self):
11655 
    return
11656 
 
11657 
 
11658 
  def __repr__(self):
11659 
    L = ['%s=%r' % (key, value)
11660 
      for key, value in self.__dict__.iteritems()]
11661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11662 
 
11663 
  def __eq__(self, other):
11664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11665 
 
11666 
  def __ne__(self, other):
11667 
    return not (self == other)
11668 
 
6845 amit.gupta 11669 
class getAllEntityTags_args:
11670 
 
11671 
  thrift_spec = (
11672 
  )
11673 
 
11674 
  def read(self, iprot):
11675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11677 
      return
11678 
    iprot.readStructBegin()
11679 
    while True:
11680 
      (fname, ftype, fid) = iprot.readFieldBegin()
11681 
      if ftype == TType.STOP:
11682 
        break
11683 
      else:
11684 
        iprot.skip(ftype)
11685 
      iprot.readFieldEnd()
11686 
    iprot.readStructEnd()
11687 
 
11688 
  def write(self, oprot):
11689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11691 
      return
11692 
    oprot.writeStructBegin('getAllEntityTags_args')
11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
11696 
  def validate(self):
11697 
    return
11698 
 
11699 
 
11700 
  def __repr__(self):
11701 
    L = ['%s=%r' % (key, value)
11702 
      for key, value in self.__dict__.iteritems()]
11703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11704 
 
11705 
  def __eq__(self, other):
11706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11707 
 
11708 
  def __ne__(self, other):
11709 
    return not (self == other)
11710 
 
11711 
class getAllEntityTags_result:
11712 
  """
11713 
  Attributes:
11714 
   - success
11715 
  """
11716 
 
11717 
  thrift_spec = (
11718 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11719 
  )
11720 
 
11721 
  def __init__(self, success=None,):
11722 
    self.success = success
11723 
 
11724 
  def read(self, iprot):
11725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11727 
      return
11728 
    iprot.readStructBegin()
11729 
    while True:
11730 
      (fname, ftype, fid) = iprot.readFieldBegin()
11731 
      if ftype == TType.STOP:
11732 
        break
11733 
      if fid == 0:
11734 
        if ftype == TType.MAP:
11735 
          self.success = {}
8590 kshitij.so 11736 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11737 
          for _i183 in xrange(_size179):
11738 
            _key184 = iprot.readI64();
11739 
            _val185 = []
11740 
            (_etype189, _size186) = iprot.readListBegin()
11741 
            for _i190 in xrange(_size186):
11742 
              _elem191 = iprot.readString();
11743 
              _val185.append(_elem191)
6845 amit.gupta 11744 
            iprot.readListEnd()
8590 kshitij.so 11745 
            self.success[_key184] = _val185
6845 amit.gupta 11746 
          iprot.readMapEnd()
11747 
        else:
11748 
          iprot.skip(ftype)
11749 
      else:
11750 
        iprot.skip(ftype)
11751 
      iprot.readFieldEnd()
11752 
    iprot.readStructEnd()
11753 
 
11754 
  def write(self, oprot):
11755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11757 
      return
11758 
    oprot.writeStructBegin('getAllEntityTags_result')
11759 
    if self.success is not None:
11760 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11761 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 11762 
      for kiter192,viter193 in self.success.items():
11763 
        oprot.writeI64(kiter192)
11764 
        oprot.writeListBegin(TType.STRING, len(viter193))
11765 
        for iter194 in viter193:
11766 
          oprot.writeString(iter194)
6845 amit.gupta 11767 
        oprot.writeListEnd()
11768 
      oprot.writeMapEnd()
11769 
      oprot.writeFieldEnd()
11770 
    oprot.writeFieldStop()
11771 
    oprot.writeStructEnd()
11772 
 
11773 
  def validate(self):
11774 
    return
11775 
 
11776 
 
11777 
  def __repr__(self):
11778 
    L = ['%s=%r' % (key, value)
11779 
      for key, value in self.__dict__.iteritems()]
11780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11781 
 
11782 
  def __eq__(self, other):
11783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11784 
 
11785 
  def __ne__(self, other):
11786 
    return not (self == other)
11787 
 
6850 kshitij.so 11788 
class addBanner_args:
11789 
  """
11790 
  Attributes:
8590 kshitij.so 11791 
   - bannerCongregate
6850 kshitij.so 11792 
  """
11793 
 
11794 
  thrift_spec = (
11795 
    None, # 0
8590 kshitij.so 11796 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 11797 
  )
11798 
 
8590 kshitij.so 11799 
  def __init__(self, bannerCongregate=None,):
11800 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 11801 
 
11802 
  def read(self, iprot):
11803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11805 
      return
11806 
    iprot.readStructBegin()
11807 
    while True:
11808 
      (fname, ftype, fid) = iprot.readFieldBegin()
11809 
      if ftype == TType.STOP:
11810 
        break
11811 
      if fid == 1:
8579 kshitij.so 11812 
        if ftype == TType.STRUCT:
8590 kshitij.so 11813 
          self.bannerCongregate = BannerCongregate()
11814 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 11815 
        else:
11816 
          iprot.skip(ftype)
8579 kshitij.so 11817 
      else:
11818 
        iprot.skip(ftype)
11819 
      iprot.readFieldEnd()
11820 
    iprot.readStructEnd()
11821 
 
11822 
  def write(self, oprot):
11823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11825 
      return
11826 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 11827 
    if self.bannerCongregate is not None:
11828 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
11829 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 11830 
      oprot.writeFieldEnd()
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 addBanner_result:
11850 
 
11851 
  thrift_spec = (
11852 
  )
11853 
 
11854 
  def read(self, iprot):
11855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11857 
      return
11858 
    iprot.readStructBegin()
11859 
    while True:
11860 
      (fname, ftype, fid) = iprot.readFieldBegin()
11861 
      if ftype == TType.STOP:
11862 
        break
11863 
      else:
11864 
        iprot.skip(ftype)
11865 
      iprot.readFieldEnd()
11866 
    iprot.readStructEnd()
11867 
 
11868 
  def write(self, oprot):
11869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11871 
      return
11872 
    oprot.writeStructBegin('addBanner_result')
11873 
    oprot.writeFieldStop()
11874 
    oprot.writeStructEnd()
11875 
 
11876 
  def validate(self):
11877 
    return
11878 
 
11879 
 
11880 
  def __repr__(self):
11881 
    L = ['%s=%r' % (key, value)
11882 
      for key, value in self.__dict__.iteritems()]
11883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11884 
 
11885 
  def __eq__(self, other):
11886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11887 
 
11888 
  def __ne__(self, other):
11889 
    return not (self == other)
11890 
 
11891 
class updateBanner_args:
11892 
  """
11893 
  Attributes:
11894 
   - banner
11895 
  """
11896 
 
11897 
  thrift_spec = (
11898 
    None, # 0
11899 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
11900 
  )
11901 
 
11902 
  def __init__(self, banner=None,):
11903 
    self.banner = banner
11904 
 
11905 
  def read(self, iprot):
11906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11908 
      return
11909 
    iprot.readStructBegin()
11910 
    while True:
11911 
      (fname, ftype, fid) = iprot.readFieldBegin()
11912 
      if ftype == TType.STOP:
11913 
        break
11914 
      if fid == 1:
11915 
        if ftype == TType.STRUCT:
11916 
          self.banner = Banner()
11917 
          self.banner.read(iprot)
6850 kshitij.so 11918 
        else:
11919 
          iprot.skip(ftype)
11920 
      else:
11921 
        iprot.skip(ftype)
11922 
      iprot.readFieldEnd()
11923 
    iprot.readStructEnd()
11924 
 
11925 
  def write(self, oprot):
11926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11928 
      return
8579 kshitij.so 11929 
    oprot.writeStructBegin('updateBanner_args')
11930 
    if self.banner is not None:
11931 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
11932 
      self.banner.write(oprot)
6850 kshitij.so 11933 
      oprot.writeFieldEnd()
11934 
    oprot.writeFieldStop()
11935 
    oprot.writeStructEnd()
11936 
 
11937 
  def validate(self):
11938 
    return
11939 
 
11940 
 
11941 
  def __repr__(self):
11942 
    L = ['%s=%r' % (key, value)
11943 
      for key, value in self.__dict__.iteritems()]
11944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11945 
 
11946 
  def __eq__(self, other):
11947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11948 
 
11949 
  def __ne__(self, other):
11950 
    return not (self == other)
11951 
 
8579 kshitij.so 11952 
class updateBanner_result:
6850 kshitij.so 11953 
  """
11954 
  Attributes:
11955 
   - success
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    (0, TType.BOOL, 'success', None, None, ), # 0
11960 
  )
11961 
 
11962 
  def __init__(self, success=None,):
11963 
    self.success = success
11964 
 
11965 
  def read(self, iprot):
11966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11968 
      return
11969 
    iprot.readStructBegin()
11970 
    while True:
11971 
      (fname, ftype, fid) = iprot.readFieldBegin()
11972 
      if ftype == TType.STOP:
11973 
        break
11974 
      if fid == 0:
11975 
        if ftype == TType.BOOL:
11976 
          self.success = iprot.readBool();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      else:
11980 
        iprot.skip(ftype)
11981 
      iprot.readFieldEnd()
11982 
    iprot.readStructEnd()
11983 
 
11984 
  def write(self, oprot):
11985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11987 
      return
8579 kshitij.so 11988 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 11989 
    if self.success is not None:
11990 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11991 
      oprot.writeBool(self.success)
11992 
      oprot.writeFieldEnd()
11993 
    oprot.writeFieldStop()
11994 
    oprot.writeStructEnd()
11995 
 
11996 
  def validate(self):
11997 
    return
11998 
 
11999 
 
12000 
  def __repr__(self):
12001 
    L = ['%s=%r' % (key, value)
12002 
      for key, value in self.__dict__.iteritems()]
12003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12004 
 
12005 
  def __eq__(self, other):
12006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12007 
 
12008 
  def __ne__(self, other):
12009 
    return not (self == other)
12010 
 
12011 
class getAllBanners_args:
12012 
 
12013 
  thrift_spec = (
12014 
  )
12015 
 
12016 
  def read(self, iprot):
12017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12019 
      return
12020 
    iprot.readStructBegin()
12021 
    while True:
12022 
      (fname, ftype, fid) = iprot.readFieldBegin()
12023 
      if ftype == TType.STOP:
12024 
        break
12025 
      else:
12026 
        iprot.skip(ftype)
12027 
      iprot.readFieldEnd()
12028 
    iprot.readStructEnd()
12029 
 
12030 
  def write(self, oprot):
12031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12033 
      return
12034 
    oprot.writeStructBegin('getAllBanners_args')
12035 
    oprot.writeFieldStop()
12036 
    oprot.writeStructEnd()
12037 
 
12038 
  def validate(self):
12039 
    return
12040 
 
12041 
 
12042 
  def __repr__(self):
12043 
    L = ['%s=%r' % (key, value)
12044 
      for key, value in self.__dict__.iteritems()]
12045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12046 
 
12047 
  def __eq__(self, other):
12048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12049 
 
12050 
  def __ne__(self, other):
12051 
    return not (self == other)
12052 
 
12053 
class getAllBanners_result:
12054 
  """
12055 
  Attributes:
12056 
   - success
12057 
  """
12058 
 
12059 
  thrift_spec = (
8579 kshitij.so 12060 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12061 
  )
12062 
 
12063 
  def __init__(self, success=None,):
12064 
    self.success = success
12065 
 
12066 
  def read(self, iprot):
12067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12069 
      return
12070 
    iprot.readStructBegin()
12071 
    while True:
12072 
      (fname, ftype, fid) = iprot.readFieldBegin()
12073 
      if ftype == TType.STOP:
12074 
        break
12075 
      if fid == 0:
12076 
        if ftype == TType.LIST:
12077 
          self.success = []
8590 kshitij.so 12078 
          (_etype198, _size195) = iprot.readListBegin()
12079 
          for _i199 in xrange(_size195):
12080 
            _elem200 = Banner()
12081 
            _elem200.read(iprot)
12082 
            self.success.append(_elem200)
6850 kshitij.so 12083 
          iprot.readListEnd()
12084 
        else:
12085 
          iprot.skip(ftype)
12086 
      else:
12087 
        iprot.skip(ftype)
12088 
      iprot.readFieldEnd()
12089 
    iprot.readStructEnd()
12090 
 
12091 
  def write(self, oprot):
12092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12094 
      return
12095 
    oprot.writeStructBegin('getAllBanners_result')
12096 
    if self.success is not None:
12097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12098 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12099 
      for iter201 in self.success:
12100 
        iter201.write(oprot)
6850 kshitij.so 12101 
      oprot.writeListEnd()
12102 
      oprot.writeFieldEnd()
12103 
    oprot.writeFieldStop()
12104 
    oprot.writeStructEnd()
12105 
 
12106 
  def validate(self):
12107 
    return
12108 
 
12109 
 
12110 
  def __repr__(self):
12111 
    L = ['%s=%r' % (key, value)
12112 
      for key, value in self.__dict__.iteritems()]
12113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12114 
 
12115 
  def __eq__(self, other):
12116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12117 
 
12118 
  def __ne__(self, other):
12119 
    return not (self == other)
12120 
 
12121 
class deleteBanner_args:
12122 
  """
12123 
  Attributes:
12124 
   - bannerName
12125 
  """
12126 
 
12127 
  thrift_spec = (
12128 
    None, # 0
12129 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12130 
  )
12131 
 
12132 
  def __init__(self, bannerName=None,):
12133 
    self.bannerName = bannerName
12134 
 
12135 
  def read(self, iprot):
12136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12138 
      return
12139 
    iprot.readStructBegin()
12140 
    while True:
12141 
      (fname, ftype, fid) = iprot.readFieldBegin()
12142 
      if ftype == TType.STOP:
12143 
        break
12144 
      if fid == 1:
12145 
        if ftype == TType.STRING:
12146 
          self.bannerName = iprot.readString();
12147 
        else:
12148 
          iprot.skip(ftype)
12149 
      else:
12150 
        iprot.skip(ftype)
12151 
      iprot.readFieldEnd()
12152 
    iprot.readStructEnd()
12153 
 
12154 
  def write(self, oprot):
12155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12157 
      return
12158 
    oprot.writeStructBegin('deleteBanner_args')
12159 
    if self.bannerName is not None:
12160 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12161 
      oprot.writeString(self.bannerName)
12162 
      oprot.writeFieldEnd()
12163 
    oprot.writeFieldStop()
12164 
    oprot.writeStructEnd()
12165 
 
12166 
  def validate(self):
12167 
    return
12168 
 
12169 
 
12170 
  def __repr__(self):
12171 
    L = ['%s=%r' % (key, value)
12172 
      for key, value in self.__dict__.iteritems()]
12173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12174 
 
12175 
  def __eq__(self, other):
12176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12177 
 
12178 
  def __ne__(self, other):
12179 
    return not (self == other)
12180 
 
12181 
class deleteBanner_result:
12182 
  """
12183 
  Attributes:
12184 
   - success
12185 
  """
12186 
 
12187 
  thrift_spec = (
12188 
    (0, TType.BOOL, 'success', None, None, ), # 0
12189 
  )
12190 
 
12191 
  def __init__(self, success=None,):
12192 
    self.success = success
12193 
 
12194 
  def read(self, iprot):
12195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12197 
      return
12198 
    iprot.readStructBegin()
12199 
    while True:
12200 
      (fname, ftype, fid) = iprot.readFieldBegin()
12201 
      if ftype == TType.STOP:
12202 
        break
12203 
      if fid == 0:
12204 
        if ftype == TType.BOOL:
12205 
          self.success = iprot.readBool();
12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
12217 
    oprot.writeStructBegin('deleteBanner_result')
12218 
    if self.success is not None:
12219 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12220 
      oprot.writeBool(self.success)
12221 
      oprot.writeFieldEnd()
12222 
    oprot.writeFieldStop()
12223 
    oprot.writeStructEnd()
12224 
 
12225 
  def validate(self):
12226 
    return
12227 
 
12228 
 
12229 
  def __repr__(self):
12230 
    L = ['%s=%r' % (key, value)
12231 
      for key, value in self.__dict__.iteritems()]
12232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12233 
 
12234 
  def __eq__(self, other):
12235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12236 
 
12237 
  def __ne__(self, other):
12238 
    return not (self == other)
12239 
 
12240 
class getBannerDetails_args:
12241 
  """
12242 
  Attributes:
12243 
   - bannerName
12244 
  """
12245 
 
12246 
  thrift_spec = (
12247 
    None, # 0
12248 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12249 
  )
12250 
 
12251 
  def __init__(self, bannerName=None,):
12252 
    self.bannerName = bannerName
12253 
 
12254 
  def read(self, iprot):
12255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12257 
      return
12258 
    iprot.readStructBegin()
12259 
    while True:
12260 
      (fname, ftype, fid) = iprot.readFieldBegin()
12261 
      if ftype == TType.STOP:
12262 
        break
12263 
      if fid == 1:
12264 
        if ftype == TType.STRING:
12265 
          self.bannerName = iprot.readString();
12266 
        else:
12267 
          iprot.skip(ftype)
12268 
      else:
12269 
        iprot.skip(ftype)
12270 
      iprot.readFieldEnd()
12271 
    iprot.readStructEnd()
12272 
 
12273 
  def write(self, oprot):
12274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12276 
      return
12277 
    oprot.writeStructBegin('getBannerDetails_args')
12278 
    if self.bannerName is not None:
12279 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12280 
      oprot.writeString(self.bannerName)
12281 
      oprot.writeFieldEnd()
12282 
    oprot.writeFieldStop()
12283 
    oprot.writeStructEnd()
12284 
 
12285 
  def validate(self):
12286 
    return
12287 
 
12288 
 
12289 
  def __repr__(self):
12290 
    L = ['%s=%r' % (key, value)
12291 
      for key, value in self.__dict__.iteritems()]
12292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12293 
 
12294 
  def __eq__(self, other):
12295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12296 
 
12297 
  def __ne__(self, other):
12298 
    return not (self == other)
12299 
 
12300 
class getBannerDetails_result:
12301 
  """
12302 
  Attributes:
12303 
   - success
12304 
  """
12305 
 
12306 
  thrift_spec = (
12307 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12308 
  )
12309 
 
12310 
  def __init__(self, success=None,):
12311 
    self.success = success
12312 
 
12313 
  def read(self, iprot):
12314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12316 
      return
12317 
    iprot.readStructBegin()
12318 
    while True:
12319 
      (fname, ftype, fid) = iprot.readFieldBegin()
12320 
      if ftype == TType.STOP:
12321 
        break
12322 
      if fid == 0:
12323 
        if ftype == TType.STRUCT:
12324 
          self.success = Banner()
12325 
          self.success.read(iprot)
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      else:
12329 
        iprot.skip(ftype)
12330 
      iprot.readFieldEnd()
12331 
    iprot.readStructEnd()
12332 
 
12333 
  def write(self, oprot):
12334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12336 
      return
12337 
    oprot.writeStructBegin('getBannerDetails_result')
12338 
    if self.success is not None:
12339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12340 
      self.success.write(oprot)
12341 
      oprot.writeFieldEnd()
12342 
    oprot.writeFieldStop()
12343 
    oprot.writeStructEnd()
12344 
 
12345 
  def validate(self):
12346 
    return
12347 
 
12348 
 
12349 
  def __repr__(self):
12350 
    L = ['%s=%r' % (key, value)
12351 
      for key, value in self.__dict__.iteritems()]
12352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12353 
 
12354 
  def __eq__(self, other):
12355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12356 
 
12357 
  def __ne__(self, other):
12358 
    return not (self == other)
12359 
 
12360 
class getActiveBanners_args:
12361 
 
12362 
  thrift_spec = (
12363 
  )
12364 
 
12365 
  def read(self, iprot):
12366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12368 
      return
12369 
    iprot.readStructBegin()
12370 
    while True:
12371 
      (fname, ftype, fid) = iprot.readFieldBegin()
12372 
      if ftype == TType.STOP:
12373 
        break
12374 
      else:
12375 
        iprot.skip(ftype)
12376 
      iprot.readFieldEnd()
12377 
    iprot.readStructEnd()
12378 
 
12379 
  def write(self, oprot):
12380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12382 
      return
12383 
    oprot.writeStructBegin('getActiveBanners_args')
12384 
    oprot.writeFieldStop()
12385 
    oprot.writeStructEnd()
12386 
 
12387 
  def validate(self):
12388 
    return
12389 
 
12390 
 
12391 
  def __repr__(self):
12392 
    L = ['%s=%r' % (key, value)
12393 
      for key, value in self.__dict__.iteritems()]
12394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12395 
 
12396 
  def __eq__(self, other):
12397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12398 
 
12399 
  def __ne__(self, other):
12400 
    return not (self == other)
12401 
 
12402 
class getActiveBanners_result:
12403 
  """
12404 
  Attributes:
12405 
   - success
12406 
  """
12407 
 
12408 
  thrift_spec = (
8579 kshitij.so 12409 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12410 
  )
12411 
 
12412 
  def __init__(self, success=None,):
12413 
    self.success = success
12414 
 
12415 
  def read(self, iprot):
12416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12418 
      return
12419 
    iprot.readStructBegin()
12420 
    while True:
12421 
      (fname, ftype, fid) = iprot.readFieldBegin()
12422 
      if ftype == TType.STOP:
12423 
        break
12424 
      if fid == 0:
8579 kshitij.so 12425 
        if ftype == TType.MAP:
12426 
          self.success = {}
8590 kshitij.so 12427 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12428 
          for _i206 in xrange(_size202):
12429 
            _key207 = iprot.readString();
12430 
            _val208 = []
12431 
            (_etype212, _size209) = iprot.readListBegin()
12432 
            for _i213 in xrange(_size209):
12433 
              _elem214 = Banner()
12434 
              _elem214.read(iprot)
12435 
              _val208.append(_elem214)
8579 kshitij.so 12436 
            iprot.readListEnd()
8590 kshitij.so 12437 
            self.success[_key207] = _val208
8579 kshitij.so 12438 
          iprot.readMapEnd()
6850 kshitij.so 12439 
        else:
12440 
          iprot.skip(ftype)
12441 
      else:
12442 
        iprot.skip(ftype)
12443 
      iprot.readFieldEnd()
12444 
    iprot.readStructEnd()
12445 
 
12446 
  def write(self, oprot):
12447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12449 
      return
12450 
    oprot.writeStructBegin('getActiveBanners_result')
12451 
    if self.success is not None:
8579 kshitij.so 12452 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12453 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12454 
      for kiter215,viter216 in self.success.items():
12455 
        oprot.writeString(kiter215)
12456 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12457 
        for iter217 in viter216:
12458 
          iter217.write(oprot)
8579 kshitij.so 12459 
        oprot.writeListEnd()
12460 
      oprot.writeMapEnd()
6850 kshitij.so 12461 
      oprot.writeFieldEnd()
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
6849 kshitij.so 12480 
class addBannerMap_args:
12481 
  """
12482 
  Attributes:
8579 kshitij.so 12483 
   - bannerMaps
6849 kshitij.so 12484 
  """
12485 
 
12486 
  thrift_spec = (
12487 
    None, # 0
8579 kshitij.so 12488 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12489 
  )
12490 
 
8579 kshitij.so 12491 
  def __init__(self, bannerMaps=None,):
12492 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12493 
 
12494 
  def read(self, iprot):
12495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12497 
      return
12498 
    iprot.readStructBegin()
12499 
    while True:
12500 
      (fname, ftype, fid) = iprot.readFieldBegin()
12501 
      if ftype == TType.STOP:
12502 
        break
12503 
      if fid == 1:
8579 kshitij.so 12504 
        if ftype == TType.LIST:
12505 
          self.bannerMaps = []
8590 kshitij.so 12506 
          (_etype221, _size218) = iprot.readListBegin()
12507 
          for _i222 in xrange(_size218):
12508 
            _elem223 = BannerMap()
12509 
            _elem223.read(iprot)
12510 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12511 
          iprot.readListEnd()
6849 kshitij.so 12512 
        else:
12513 
          iprot.skip(ftype)
8579 kshitij.so 12514 
      else:
12515 
        iprot.skip(ftype)
12516 
      iprot.readFieldEnd()
12517 
    iprot.readStructEnd()
12518 
 
12519 
  def write(self, oprot):
12520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12522 
      return
12523 
    oprot.writeStructBegin('addBannerMap_args')
12524 
    if self.bannerMaps is not None:
12525 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12526 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12527 
      for iter224 in self.bannerMaps:
12528 
        iter224.write(oprot)
8579 kshitij.so 12529 
      oprot.writeListEnd()
12530 
      oprot.writeFieldEnd()
12531 
    oprot.writeFieldStop()
12532 
    oprot.writeStructEnd()
12533 
 
12534 
  def validate(self):
12535 
    return
12536 
 
12537 
 
12538 
  def __repr__(self):
12539 
    L = ['%s=%r' % (key, value)
12540 
      for key, value in self.__dict__.iteritems()]
12541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12542 
 
12543 
  def __eq__(self, other):
12544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12545 
 
12546 
  def __ne__(self, other):
12547 
    return not (self == other)
12548 
 
12549 
class addBannerMap_result:
12550 
  """
12551 
  Attributes:
12552 
   - success
12553 
  """
12554 
 
12555 
  thrift_spec = (
12556 
    (0, TType.BOOL, 'success', None, None, ), # 0
12557 
  )
12558 
 
12559 
  def __init__(self, success=None,):
12560 
    self.success = success
12561 
 
12562 
  def read(self, iprot):
12563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12565 
      return
12566 
    iprot.readStructBegin()
12567 
    while True:
12568 
      (fname, ftype, fid) = iprot.readFieldBegin()
12569 
      if ftype == TType.STOP:
12570 
        break
12571 
      if fid == 0:
12572 
        if ftype == TType.BOOL:
12573 
          self.success = iprot.readBool();
6849 kshitij.so 12574 
        else:
12575 
          iprot.skip(ftype)
8579 kshitij.so 12576 
      else:
12577 
        iprot.skip(ftype)
12578 
      iprot.readFieldEnd()
12579 
    iprot.readStructEnd()
12580 
 
12581 
  def write(self, oprot):
12582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12584 
      return
12585 
    oprot.writeStructBegin('addBannerMap_result')
12586 
    if self.success is not None:
12587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12588 
      oprot.writeBool(self.success)
12589 
      oprot.writeFieldEnd()
12590 
    oprot.writeFieldStop()
12591 
    oprot.writeStructEnd()
12592 
 
12593 
  def validate(self):
12594 
    return
12595 
 
12596 
 
12597 
  def __repr__(self):
12598 
    L = ['%s=%r' % (key, value)
12599 
      for key, value in self.__dict__.iteritems()]
12600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12601 
 
12602 
  def __eq__(self, other):
12603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12604 
 
12605 
  def __ne__(self, other):
12606 
    return not (self == other)
12607 
 
12608 
class updateBannerMap_args:
12609 
  """
12610 
  Attributes:
12611 
   - bannerMap
12612 
  """
12613 
 
12614 
  thrift_spec = (
12615 
    None, # 0
12616 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12617 
  )
12618 
 
12619 
  def __init__(self, bannerMap=None,):
12620 
    self.bannerMap = bannerMap
12621 
 
12622 
  def read(self, iprot):
12623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12625 
      return
12626 
    iprot.readStructBegin()
12627 
    while True:
12628 
      (fname, ftype, fid) = iprot.readFieldBegin()
12629 
      if ftype == TType.STOP:
12630 
        break
12631 
      if fid == 1:
12632 
        if ftype == TType.STRUCT:
12633 
          self.bannerMap = BannerMap()
12634 
          self.bannerMap.read(iprot)
6849 kshitij.so 12635 
        else:
12636 
          iprot.skip(ftype)
12637 
      else:
12638 
        iprot.skip(ftype)
12639 
      iprot.readFieldEnd()
12640 
    iprot.readStructEnd()
12641 
 
12642 
  def write(self, oprot):
12643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12645 
      return
8579 kshitij.so 12646 
    oprot.writeStructBegin('updateBannerMap_args')
12647 
    if self.bannerMap is not None:
12648 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12649 
      self.bannerMap.write(oprot)
6849 kshitij.so 12650 
      oprot.writeFieldEnd()
12651 
    oprot.writeFieldStop()
12652 
    oprot.writeStructEnd()
12653 
 
12654 
  def validate(self):
12655 
    return
12656 
 
12657 
 
12658 
  def __repr__(self):
12659 
    L = ['%s=%r' % (key, value)
12660 
      for key, value in self.__dict__.iteritems()]
12661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12662 
 
12663 
  def __eq__(self, other):
12664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12665 
 
12666 
  def __ne__(self, other):
12667 
    return not (self == other)
12668 
 
8579 kshitij.so 12669 
class updateBannerMap_result:
6849 kshitij.so 12670 
  """
12671 
  Attributes:
12672 
   - success
12673 
  """
12674 
 
12675 
  thrift_spec = (
12676 
    (0, TType.BOOL, 'success', None, None, ), # 0
12677 
  )
12678 
 
12679 
  def __init__(self, success=None,):
12680 
    self.success = success
12681 
 
12682 
  def read(self, iprot):
12683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12685 
      return
12686 
    iprot.readStructBegin()
12687 
    while True:
12688 
      (fname, ftype, fid) = iprot.readFieldBegin()
12689 
      if ftype == TType.STOP:
12690 
        break
12691 
      if fid == 0:
12692 
        if ftype == TType.BOOL:
12693 
          self.success = iprot.readBool();
12694 
        else:
12695 
          iprot.skip(ftype)
12696 
      else:
12697 
        iprot.skip(ftype)
12698 
      iprot.readFieldEnd()
12699 
    iprot.readStructEnd()
12700 
 
12701 
  def write(self, oprot):
12702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12704 
      return
8579 kshitij.so 12705 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12706 
    if self.success is not None:
12707 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12708 
      oprot.writeBool(self.success)
12709 
      oprot.writeFieldEnd()
12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class deleteBannerMap_args:
12729 
  """
12730 
  Attributes:
12731 
   - bannerName
12732 
  """
12733 
 
12734 
  thrift_spec = (
12735 
    None, # 0
12736 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12737 
  )
12738 
 
12739 
  def __init__(self, bannerName=None,):
12740 
    self.bannerName = bannerName
12741 
 
12742 
  def read(self, iprot):
12743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12745 
      return
12746 
    iprot.readStructBegin()
12747 
    while True:
12748 
      (fname, ftype, fid) = iprot.readFieldBegin()
12749 
      if ftype == TType.STOP:
12750 
        break
12751 
      if fid == 1:
12752 
        if ftype == TType.STRING:
12753 
          self.bannerName = iprot.readString();
12754 
        else:
12755 
          iprot.skip(ftype)
12756 
      else:
12757 
        iprot.skip(ftype)
12758 
      iprot.readFieldEnd()
12759 
    iprot.readStructEnd()
12760 
 
12761 
  def write(self, oprot):
12762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12764 
      return
12765 
    oprot.writeStructBegin('deleteBannerMap_args')
12766 
    if self.bannerName is not None:
12767 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12768 
      oprot.writeString(self.bannerName)
12769 
      oprot.writeFieldEnd()
12770 
    oprot.writeFieldStop()
12771 
    oprot.writeStructEnd()
12772 
 
12773 
  def validate(self):
12774 
    return
12775 
 
12776 
 
12777 
  def __repr__(self):
12778 
    L = ['%s=%r' % (key, value)
12779 
      for key, value in self.__dict__.iteritems()]
12780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12781 
 
12782 
  def __eq__(self, other):
12783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12784 
 
12785 
  def __ne__(self, other):
12786 
    return not (self == other)
12787 
 
12788 
class deleteBannerMap_result:
12789 
  """
12790 
  Attributes:
12791 
   - success
12792 
  """
12793 
 
12794 
  thrift_spec = (
12795 
    (0, TType.BOOL, 'success', None, None, ), # 0
12796 
  )
12797 
 
12798 
  def __init__(self, success=None,):
12799 
    self.success = success
12800 
 
12801 
  def read(self, iprot):
12802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12804 
      return
12805 
    iprot.readStructBegin()
12806 
    while True:
12807 
      (fname, ftype, fid) = iprot.readFieldBegin()
12808 
      if ftype == TType.STOP:
12809 
        break
12810 
      if fid == 0:
12811 
        if ftype == TType.BOOL:
12812 
          self.success = iprot.readBool();
12813 
        else:
12814 
          iprot.skip(ftype)
12815 
      else:
12816 
        iprot.skip(ftype)
12817 
      iprot.readFieldEnd()
12818 
    iprot.readStructEnd()
12819 
 
12820 
  def write(self, oprot):
12821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12823 
      return
12824 
    oprot.writeStructBegin('deleteBannerMap_result')
12825 
    if self.success is not None:
12826 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12827 
      oprot.writeBool(self.success)
12828 
      oprot.writeFieldEnd()
12829 
    oprot.writeFieldStop()
12830 
    oprot.writeStructEnd()
12831 
 
12832 
  def validate(self):
12833 
    return
12834 
 
12835 
 
12836 
  def __repr__(self):
12837 
    L = ['%s=%r' % (key, value)
12838 
      for key, value in self.__dict__.iteritems()]
12839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12840 
 
12841 
  def __eq__(self, other):
12842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12843 
 
12844 
  def __ne__(self, other):
12845 
    return not (self == other)
12846 
 
12847 
class getBannerMapDetails_args:
12848 
  """
12849 
  Attributes:
12850 
   - bannerName
12851 
  """
12852 
 
12853 
  thrift_spec = (
12854 
    None, # 0
12855 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12856 
  )
12857 
 
12858 
  def __init__(self, bannerName=None,):
12859 
    self.bannerName = bannerName
12860 
 
12861 
  def read(self, iprot):
12862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12864 
      return
12865 
    iprot.readStructBegin()
12866 
    while True:
12867 
      (fname, ftype, fid) = iprot.readFieldBegin()
12868 
      if ftype == TType.STOP:
12869 
        break
12870 
      if fid == 1:
12871 
        if ftype == TType.STRING:
12872 
          self.bannerName = iprot.readString();
12873 
        else:
12874 
          iprot.skip(ftype)
12875 
      else:
12876 
        iprot.skip(ftype)
12877 
      iprot.readFieldEnd()
12878 
    iprot.readStructEnd()
12879 
 
12880 
  def write(self, oprot):
12881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12883 
      return
12884 
    oprot.writeStructBegin('getBannerMapDetails_args')
12885 
    if self.bannerName is not None:
12886 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12887 
      oprot.writeString(self.bannerName)
12888 
      oprot.writeFieldEnd()
12889 
    oprot.writeFieldStop()
12890 
    oprot.writeStructEnd()
12891 
 
12892 
  def validate(self):
12893 
    return
12894 
 
12895 
 
12896 
  def __repr__(self):
12897 
    L = ['%s=%r' % (key, value)
12898 
      for key, value in self.__dict__.iteritems()]
12899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12900 
 
12901 
  def __eq__(self, other):
12902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12903 
 
12904 
  def __ne__(self, other):
12905 
    return not (self == other)
12906 
 
12907 
class getBannerMapDetails_result:
12908 
  """
12909 
  Attributes:
12910 
   - success
12911 
  """
12912 
 
12913 
  thrift_spec = (
12914 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12915 
  )
12916 
 
12917 
  def __init__(self, success=None,):
12918 
    self.success = success
12919 
 
12920 
  def read(self, iprot):
12921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12923 
      return
12924 
    iprot.readStructBegin()
12925 
    while True:
12926 
      (fname, ftype, fid) = iprot.readFieldBegin()
12927 
      if ftype == TType.STOP:
12928 
        break
12929 
      if fid == 0:
12930 
        if ftype == TType.LIST:
12931 
          self.success = []
8590 kshitij.so 12932 
          (_etype228, _size225) = iprot.readListBegin()
12933 
          for _i229 in xrange(_size225):
12934 
            _elem230 = BannerMap()
12935 
            _elem230.read(iprot)
12936 
            self.success.append(_elem230)
6849 kshitij.so 12937 
          iprot.readListEnd()
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      else:
12941 
        iprot.skip(ftype)
12942 
      iprot.readFieldEnd()
12943 
    iprot.readStructEnd()
12944 
 
12945 
  def write(self, oprot):
12946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12948 
      return
12949 
    oprot.writeStructBegin('getBannerMapDetails_result')
12950 
    if self.success is not None:
12951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12953 
      for iter231 in self.success:
12954 
        iter231.write(oprot)
6849 kshitij.so 12955 
      oprot.writeListEnd()
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
8579 kshitij.so 12975 
class addBannerUri_args:
12976 
  """
12977 
  Attributes:
12978 
   - bannerUriMappings
12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    None, # 0
12983 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
12984 
  )
12985 
 
12986 
  def __init__(self, bannerUriMappings=None,):
12987 
    self.bannerUriMappings = bannerUriMappings
12988 
 
12989 
  def read(self, iprot):
12990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12992 
      return
12993 
    iprot.readStructBegin()
12994 
    while True:
12995 
      (fname, ftype, fid) = iprot.readFieldBegin()
12996 
      if ftype == TType.STOP:
12997 
        break
12998 
      if fid == 1:
12999 
        if ftype == TType.LIST:
13000 
          self.bannerUriMappings = []
8590 kshitij.so 13001 
          (_etype235, _size232) = iprot.readListBegin()
13002 
          for _i236 in xrange(_size232):
13003 
            _elem237 = BannerUriMapping()
13004 
            _elem237.read(iprot)
13005 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13006 
          iprot.readListEnd()
13007 
        else:
13008 
          iprot.skip(ftype)
13009 
      else:
13010 
        iprot.skip(ftype)
13011 
      iprot.readFieldEnd()
13012 
    iprot.readStructEnd()
13013 
 
13014 
  def write(self, oprot):
13015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13017 
      return
13018 
    oprot.writeStructBegin('addBannerUri_args')
13019 
    if self.bannerUriMappings is not None:
13020 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13021 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13022 
      for iter238 in self.bannerUriMappings:
13023 
        iter238.write(oprot)
8579 kshitij.so 13024 
      oprot.writeListEnd()
13025 
      oprot.writeFieldEnd()
13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
13044 
class addBannerUri_result:
13045 
 
13046 
  thrift_spec = (
13047 
  )
13048 
 
13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
13058 
      else:
13059 
        iprot.skip(ftype)
13060 
      iprot.readFieldEnd()
13061 
    iprot.readStructEnd()
13062 
 
13063 
  def write(self, oprot):
13064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13066 
      return
13067 
    oprot.writeStructBegin('addBannerUri_result')
13068 
    oprot.writeFieldStop()
13069 
    oprot.writeStructEnd()
13070 
 
13071 
  def validate(self):
13072 
    return
13073 
 
13074 
 
13075 
  def __repr__(self):
13076 
    L = ['%s=%r' % (key, value)
13077 
      for key, value in self.__dict__.iteritems()]
13078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13079 
 
13080 
  def __eq__(self, other):
13081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13082 
 
13083 
  def __ne__(self, other):
13084 
    return not (self == other)
13085 
 
13086 
class getUriMapping_args:
13087 
  """
13088 
  Attributes:
13089 
   - bannerName
13090 
  """
13091 
 
13092 
  thrift_spec = (
13093 
    None, # 0
13094 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13095 
  )
13096 
 
13097 
  def __init__(self, bannerName=None,):
13098 
    self.bannerName = bannerName
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 1:
13110 
        if ftype == TType.STRING:
13111 
          self.bannerName = iprot.readString();
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      else:
13115 
        iprot.skip(ftype)
13116 
      iprot.readFieldEnd()
13117 
    iprot.readStructEnd()
13118 
 
13119 
  def write(self, oprot):
13120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13122 
      return
13123 
    oprot.writeStructBegin('getUriMapping_args')
13124 
    if self.bannerName is not None:
13125 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13126 
      oprot.writeString(self.bannerName)
13127 
      oprot.writeFieldEnd()
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class getUriMapping_result:
13147 
  """
13148 
  Attributes:
13149 
   - success
13150 
  """
13151 
 
13152 
  thrift_spec = (
13153 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13154 
  )
13155 
 
13156 
  def __init__(self, success=None,):
13157 
    self.success = success
13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 0:
13169 
        if ftype == TType.LIST:
13170 
          self.success = []
8590 kshitij.so 13171 
          (_etype242, _size239) = iprot.readListBegin()
13172 
          for _i243 in xrange(_size239):
13173 
            _elem244 = BannerUriMapping()
13174 
            _elem244.read(iprot)
13175 
            self.success.append(_elem244)
8579 kshitij.so 13176 
          iprot.readListEnd()
13177 
        else:
13178 
          iprot.skip(ftype)
13179 
      else:
13180 
        iprot.skip(ftype)
13181 
      iprot.readFieldEnd()
13182 
    iprot.readStructEnd()
13183 
 
13184 
  def write(self, oprot):
13185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13187 
      return
13188 
    oprot.writeStructBegin('getUriMapping_result')
13189 
    if self.success is not None:
13190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13192 
      for iter245 in self.success:
13193 
        iter245.write(oprot)
8579 kshitij.so 13194 
      oprot.writeListEnd()
13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
13214 
class addCampaign_args:
13215 
  """
13216 
  Attributes:
13217 
   - campaign
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13223 
  )
13224 
 
13225 
  def __init__(self, campaign=None,):
13226 
    self.campaign = campaign
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.STRUCT:
13239 
          self.campaign = Campaign()
13240 
          self.campaign.read(iprot)
13241 
        else:
13242 
          iprot.skip(ftype)
13243 
      else:
13244 
        iprot.skip(ftype)
13245 
      iprot.readFieldEnd()
13246 
    iprot.readStructEnd()
13247 
 
13248 
  def write(self, oprot):
13249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13251 
      return
13252 
    oprot.writeStructBegin('addCampaign_args')
13253 
    if self.campaign is not None:
13254 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13255 
      self.campaign.write(oprot)
13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
13275 
class addCampaign_result:
13276 
 
13277 
  thrift_spec = (
13278 
  )
13279 
 
13280 
  def read(self, iprot):
13281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13283 
      return
13284 
    iprot.readStructBegin()
13285 
    while True:
13286 
      (fname, ftype, fid) = iprot.readFieldBegin()
13287 
      if ftype == TType.STOP:
13288 
        break
13289 
      else:
13290 
        iprot.skip(ftype)
13291 
      iprot.readFieldEnd()
13292 
    iprot.readStructEnd()
13293 
 
13294 
  def write(self, oprot):
13295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13297 
      return
13298 
    oprot.writeStructBegin('addCampaign_result')
13299 
    oprot.writeFieldStop()
13300 
    oprot.writeStructEnd()
13301 
 
13302 
  def validate(self):
13303 
    return
13304 
 
13305 
 
13306 
  def __repr__(self):
13307 
    L = ['%s=%r' % (key, value)
13308 
      for key, value in self.__dict__.iteritems()]
13309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13310 
 
13311 
  def __eq__(self, other):
13312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13313 
 
13314 
  def __ne__(self, other):
13315 
    return not (self == other)
13316 
 
13317 
class getCampaigns_args:
13318 
  """
13319 
  Attributes:
13320 
   - campaignName
13321 
  """
13322 
 
13323 
  thrift_spec = (
13324 
    None, # 0
13325 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13326 
  )
13327 
 
13328 
  def __init__(self, campaignName=None,):
13329 
    self.campaignName = campaignName
13330 
 
13331 
  def read(self, iprot):
13332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13334 
      return
13335 
    iprot.readStructBegin()
13336 
    while True:
13337 
      (fname, ftype, fid) = iprot.readFieldBegin()
13338 
      if ftype == TType.STOP:
13339 
        break
13340 
      if fid == 1:
13341 
        if ftype == TType.STRING:
13342 
          self.campaignName = iprot.readString();
13343 
        else:
13344 
          iprot.skip(ftype)
13345 
      else:
13346 
        iprot.skip(ftype)
13347 
      iprot.readFieldEnd()
13348 
    iprot.readStructEnd()
13349 
 
13350 
  def write(self, oprot):
13351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13353 
      return
13354 
    oprot.writeStructBegin('getCampaigns_args')
13355 
    if self.campaignName is not None:
13356 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13357 
      oprot.writeString(self.campaignName)
13358 
      oprot.writeFieldEnd()
13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
13376 
 
13377 
class getCampaigns_result:
13378 
  """
13379 
  Attributes:
13380 
   - success
13381 
  """
13382 
 
13383 
  thrift_spec = (
13384 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13385 
  )
13386 
 
13387 
  def __init__(self, success=None,):
13388 
    self.success = success
13389 
 
13390 
  def read(self, iprot):
13391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13393 
      return
13394 
    iprot.readStructBegin()
13395 
    while True:
13396 
      (fname, ftype, fid) = iprot.readFieldBegin()
13397 
      if ftype == TType.STOP:
13398 
        break
13399 
      if fid == 0:
13400 
        if ftype == TType.LIST:
13401 
          self.success = []
8590 kshitij.so 13402 
          (_etype249, _size246) = iprot.readListBegin()
13403 
          for _i250 in xrange(_size246):
13404 
            _elem251 = Campaign()
13405 
            _elem251.read(iprot)
13406 
            self.success.append(_elem251)
8579 kshitij.so 13407 
          iprot.readListEnd()
13408 
        else:
13409 
          iprot.skip(ftype)
13410 
      else:
13411 
        iprot.skip(ftype)
13412 
      iprot.readFieldEnd()
13413 
    iprot.readStructEnd()
13414 
 
13415 
  def write(self, oprot):
13416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13418 
      return
13419 
    oprot.writeStructBegin('getCampaigns_result')
13420 
    if self.success is not None:
13421 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13422 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13423 
      for iter252 in self.success:
13424 
        iter252.write(oprot)
8579 kshitij.so 13425 
      oprot.writeListEnd()
13426 
      oprot.writeFieldEnd()
13427 
    oprot.writeFieldStop()
13428 
    oprot.writeStructEnd()
13429 
 
13430 
  def validate(self):
13431 
    return
13432 
 
13433 
 
13434 
  def __repr__(self):
13435 
    L = ['%s=%r' % (key, value)
13436 
      for key, value in self.__dict__.iteritems()]
13437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13438 
 
13439 
  def __eq__(self, other):
13440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13441 
 
13442 
  def __ne__(self, other):
13443 
    return not (self == other)
13444 
 
13445 
class deleteCampaign_args:
13446 
  """
13447 
  Attributes:
13448 
   - campaignId
13449 
  """
13450 
 
13451 
  thrift_spec = (
13452 
    None, # 0
13453 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13454 
  )
13455 
 
13456 
  def __init__(self, campaignId=None,):
13457 
    self.campaignId = campaignId
13458 
 
13459 
  def read(self, iprot):
13460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13462 
      return
13463 
    iprot.readStructBegin()
13464 
    while True:
13465 
      (fname, ftype, fid) = iprot.readFieldBegin()
13466 
      if ftype == TType.STOP:
13467 
        break
13468 
      if fid == 1:
13469 
        if ftype == TType.I64:
13470 
          self.campaignId = iprot.readI64();
13471 
        else:
13472 
          iprot.skip(ftype)
13473 
      else:
13474 
        iprot.skip(ftype)
13475 
      iprot.readFieldEnd()
13476 
    iprot.readStructEnd()
13477 
 
13478 
  def write(self, oprot):
13479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13481 
      return
13482 
    oprot.writeStructBegin('deleteCampaign_args')
13483 
    if self.campaignId is not None:
13484 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13485 
      oprot.writeI64(self.campaignId)
13486 
      oprot.writeFieldEnd()
13487 
    oprot.writeFieldStop()
13488 
    oprot.writeStructEnd()
13489 
 
13490 
  def validate(self):
13491 
    return
13492 
 
13493 
 
13494 
  def __repr__(self):
13495 
    L = ['%s=%r' % (key, value)
13496 
      for key, value in self.__dict__.iteritems()]
13497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13498 
 
13499 
  def __eq__(self, other):
13500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13501 
 
13502 
  def __ne__(self, other):
13503 
    return not (self == other)
13504 
 
13505 
class deleteCampaign_result:
13506 
 
13507 
  thrift_spec = (
13508 
  )
13509 
 
13510 
  def read(self, iprot):
13511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13513 
      return
13514 
    iprot.readStructBegin()
13515 
    while True:
13516 
      (fname, ftype, fid) = iprot.readFieldBegin()
13517 
      if ftype == TType.STOP:
13518 
        break
13519 
      else:
13520 
        iprot.skip(ftype)
13521 
      iprot.readFieldEnd()
13522 
    iprot.readStructEnd()
13523 
 
13524 
  def write(self, oprot):
13525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13527 
      return
13528 
    oprot.writeStructBegin('deleteCampaign_result')
13529 
    oprot.writeFieldStop()
13530 
    oprot.writeStructEnd()
13531 
 
13532 
  def validate(self):
13533 
    return
13534 
 
13535 
 
13536 
  def __repr__(self):
13537 
    L = ['%s=%r' % (key, value)
13538 
      for key, value in self.__dict__.iteritems()]
13539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13540 
 
13541 
  def __eq__(self, other):
13542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13543 
 
13544 
  def __ne__(self, other):
13545 
    return not (self == other)
13546 
 
13547 
class getAllCampaigns_args:
13548 
 
13549 
  thrift_spec = (
13550 
  )
13551 
 
13552 
  def read(self, iprot):
13553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13555 
      return
13556 
    iprot.readStructBegin()
13557 
    while True:
13558 
      (fname, ftype, fid) = iprot.readFieldBegin()
13559 
      if ftype == TType.STOP:
13560 
        break
13561 
      else:
13562 
        iprot.skip(ftype)
13563 
      iprot.readFieldEnd()
13564 
    iprot.readStructEnd()
13565 
 
13566 
  def write(self, oprot):
13567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13569 
      return
13570 
    oprot.writeStructBegin('getAllCampaigns_args')
13571 
    oprot.writeFieldStop()
13572 
    oprot.writeStructEnd()
13573 
 
13574 
  def validate(self):
13575 
    return
13576 
 
13577 
 
13578 
  def __repr__(self):
13579 
    L = ['%s=%r' % (key, value)
13580 
      for key, value in self.__dict__.iteritems()]
13581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13582 
 
13583 
  def __eq__(self, other):
13584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13585 
 
13586 
  def __ne__(self, other):
13587 
    return not (self == other)
13588 
 
13589 
class getAllCampaigns_result:
13590 
  """
13591 
  Attributes:
13592 
   - success
13593 
  """
13594 
 
13595 
  thrift_spec = (
13596 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13597 
  )
13598 
 
13599 
  def __init__(self, success=None,):
13600 
    self.success = success
13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
13612 
        if ftype == TType.LIST:
13613 
          self.success = []
8590 kshitij.so 13614 
          (_etype256, _size253) = iprot.readListBegin()
13615 
          for _i257 in xrange(_size253):
13616 
            _elem258 = iprot.readString();
13617 
            self.success.append(_elem258)
8579 kshitij.so 13618 
          iprot.readListEnd()
13619 
        else:
13620 
          iprot.skip(ftype)
13621 
      else:
13622 
        iprot.skip(ftype)
13623 
      iprot.readFieldEnd()
13624 
    iprot.readStructEnd()
13625 
 
13626 
  def write(self, oprot):
13627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13629 
      return
13630 
    oprot.writeStructBegin('getAllCampaigns_result')
13631 
    if self.success is not None:
13632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13633 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13634 
      for iter259 in self.success:
13635 
        oprot.writeString(iter259)
8579 kshitij.so 13636 
      oprot.writeListEnd()
13637 
      oprot.writeFieldEnd()
13638 
    oprot.writeFieldStop()
13639 
    oprot.writeStructEnd()
13640 
 
13641 
  def validate(self):
13642 
    return
13643 
 
13644 
 
13645 
  def __repr__(self):
13646 
    L = ['%s=%r' % (key, value)
13647 
      for key, value in self.__dict__.iteritems()]
13648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13649 
 
13650 
  def __eq__(self, other):
13651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13652 
 
13653 
  def __ne__(self, other):
13654 
    return not (self == other)
13655 
 
5944 mandeep.dh 13656 
class deleteSimilarItem_args:
13657 
  """
13658 
  Attributes:
13659 
   - itemId
13660 
   - catalogItemId
13661 
  """
13662 
 
13663 
  thrift_spec = (
13664 
    None, # 0
13665 
    (1, TType.I64, 'itemId', None, None, ), # 1
13666 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13667 
  )
13668 
 
13669 
  def __init__(self, itemId=None, catalogItemId=None,):
13670 
    self.itemId = itemId
13671 
    self.catalogItemId = catalogItemId
13672 
 
13673 
  def read(self, iprot):
13674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13676 
      return
13677 
    iprot.readStructBegin()
13678 
    while True:
13679 
      (fname, ftype, fid) = iprot.readFieldBegin()
13680 
      if ftype == TType.STOP:
13681 
        break
13682 
      if fid == 1:
13683 
        if ftype == TType.I64:
13684 
          self.itemId = iprot.readI64();
13685 
        else:
13686 
          iprot.skip(ftype)
13687 
      elif fid == 2:
13688 
        if ftype == TType.I64:
13689 
          self.catalogItemId = iprot.readI64();
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      else:
13693 
        iprot.skip(ftype)
13694 
      iprot.readFieldEnd()
13695 
    iprot.readStructEnd()
13696 
 
13697 
  def write(self, oprot):
13698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13700 
      return
13701 
    oprot.writeStructBegin('deleteSimilarItem_args')
13702 
    if self.itemId is not None:
13703 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13704 
      oprot.writeI64(self.itemId)
13705 
      oprot.writeFieldEnd()
13706 
    if self.catalogItemId is not None:
13707 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13708 
      oprot.writeI64(self.catalogItemId)
13709 
      oprot.writeFieldEnd()
13710 
    oprot.writeFieldStop()
13711 
    oprot.writeStructEnd()
13712 
 
13713 
  def validate(self):
13714 
    return
13715 
 
13716 
 
13717 
  def __repr__(self):
13718 
    L = ['%s=%r' % (key, value)
13719 
      for key, value in self.__dict__.iteritems()]
13720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13721 
 
13722 
  def __eq__(self, other):
13723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13724 
 
13725 
  def __ne__(self, other):
13726 
    return not (self == other)
13727 
 
13728 
class deleteSimilarItem_result:
13729 
  """
13730 
  Attributes:
13731 
   - success
13732 
   - cex
13733 
  """
13734 
 
13735 
  thrift_spec = (
13736 
    (0, TType.BOOL, 'success', None, None, ), # 0
13737 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13738 
  )
13739 
 
13740 
  def __init__(self, success=None, cex=None,):
13741 
    self.success = success
13742 
    self.cex = cex
13743 
 
13744 
  def read(self, iprot):
13745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13747 
      return
13748 
    iprot.readStructBegin()
13749 
    while True:
13750 
      (fname, ftype, fid) = iprot.readFieldBegin()
13751 
      if ftype == TType.STOP:
13752 
        break
13753 
      if fid == 0:
13754 
        if ftype == TType.BOOL:
13755 
          self.success = iprot.readBool();
13756 
        else:
13757 
          iprot.skip(ftype)
13758 
      elif fid == 1:
13759 
        if ftype == TType.STRUCT:
13760 
          self.cex = CatalogServiceException()
13761 
          self.cex.read(iprot)
13762 
        else:
13763 
          iprot.skip(ftype)
13764 
      else:
13765 
        iprot.skip(ftype)
13766 
      iprot.readFieldEnd()
13767 
    iprot.readStructEnd()
13768 
 
13769 
  def write(self, oprot):
13770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13772 
      return
13773 
    oprot.writeStructBegin('deleteSimilarItem_result')
13774 
    if self.success is not None:
13775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13776 
      oprot.writeBool(self.success)
13777 
      oprot.writeFieldEnd()
13778 
    if self.cex is not None:
13779 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13780 
      self.cex.write(oprot)
13781 
      oprot.writeFieldEnd()
13782 
    oprot.writeFieldStop()
13783 
    oprot.writeStructEnd()
13784 
 
13785 
  def validate(self):
13786 
    return
13787 
 
13788 
 
13789 
  def __repr__(self):
13790 
    L = ['%s=%r' % (key, value)
13791 
      for key, value in self.__dict__.iteritems()]
13792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13793 
 
13794 
  def __eq__(self, other):
13795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13796 
 
13797 
  def __ne__(self, other):
13798 
    return not (self == other)
13799 
 
13800 
class checkSimilarItem_args:
13801 
  """
13802 
  Attributes:
13803 
   - brand
13804 
   - modelNumber
13805 
   - modelName
13806 
   - color
13807 
  """
13808 
 
13809 
  thrift_spec = (
13810 
    None, # 0
13811 
    (1, TType.STRING, 'brand', None, None, ), # 1
13812 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
13813 
    (3, TType.STRING, 'modelName', None, None, ), # 3
13814 
    (4, TType.STRING, 'color', None, None, ), # 4
13815 
  )
13816 
 
13817 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
13818 
    self.brand = brand
13819 
    self.modelNumber = modelNumber
13820 
    self.modelName = modelName
13821 
    self.color = color
13822 
 
13823 
  def read(self, iprot):
13824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13826 
      return
13827 
    iprot.readStructBegin()
13828 
    while True:
13829 
      (fname, ftype, fid) = iprot.readFieldBegin()
13830 
      if ftype == TType.STOP:
13831 
        break
13832 
      if fid == 1:
13833 
        if ftype == TType.STRING:
13834 
          self.brand = iprot.readString();
13835 
        else:
13836 
          iprot.skip(ftype)
13837 
      elif fid == 2:
13838 
        if ftype == TType.STRING:
13839 
          self.modelNumber = iprot.readString();
13840 
        else:
13841 
          iprot.skip(ftype)
13842 
      elif fid == 3:
13843 
        if ftype == TType.STRING:
13844 
          self.modelName = iprot.readString();
13845 
        else:
13846 
          iprot.skip(ftype)
13847 
      elif fid == 4:
13848 
        if ftype == TType.STRING:
13849 
          self.color = iprot.readString();
13850 
        else:
13851 
          iprot.skip(ftype)
13852 
      else:
13853 
        iprot.skip(ftype)
13854 
      iprot.readFieldEnd()
13855 
    iprot.readStructEnd()
13856 
 
13857 
  def write(self, oprot):
13858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13860 
      return
13861 
    oprot.writeStructBegin('checkSimilarItem_args')
13862 
    if self.brand is not None:
13863 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
13864 
      oprot.writeString(self.brand)
13865 
      oprot.writeFieldEnd()
13866 
    if self.modelNumber is not None:
13867 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
13868 
      oprot.writeString(self.modelNumber)
13869 
      oprot.writeFieldEnd()
13870 
    if self.modelName is not None:
13871 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
13872 
      oprot.writeString(self.modelName)
13873 
      oprot.writeFieldEnd()
13874 
    if self.color is not None:
13875 
      oprot.writeFieldBegin('color', TType.STRING, 4)
13876 
      oprot.writeString(self.color)
13877 
      oprot.writeFieldEnd()
13878 
    oprot.writeFieldStop()
13879 
    oprot.writeStructEnd()
13880 
 
13881 
  def validate(self):
13882 
    return
13883 
 
13884 
 
13885 
  def __repr__(self):
13886 
    L = ['%s=%r' % (key, value)
13887 
      for key, value in self.__dict__.iteritems()]
13888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13889 
 
13890 
  def __eq__(self, other):
13891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13892 
 
13893 
  def __ne__(self, other):
13894 
    return not (self == other)
13895 
 
13896 
class checkSimilarItem_result:
13897 
  """
13898 
  Attributes:
13899 
   - success
13900 
  """
13901 
 
13902 
  thrift_spec = (
13903 
    (0, TType.I64, 'success', None, None, ), # 0
13904 
  )
13905 
 
13906 
  def __init__(self, success=None,):
13907 
    self.success = success
13908 
 
13909 
  def read(self, iprot):
13910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13912 
      return
13913 
    iprot.readStructBegin()
13914 
    while True:
13915 
      (fname, ftype, fid) = iprot.readFieldBegin()
13916 
      if ftype == TType.STOP:
13917 
        break
13918 
      if fid == 0:
13919 
        if ftype == TType.I64:
13920 
          self.success = iprot.readI64();
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      else:
13924 
        iprot.skip(ftype)
13925 
      iprot.readFieldEnd()
13926 
    iprot.readStructEnd()
13927 
 
13928 
  def write(self, oprot):
13929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13931 
      return
13932 
    oprot.writeStructBegin('checkSimilarItem_result')
13933 
    if self.success is not None:
13934 
      oprot.writeFieldBegin('success', TType.I64, 0)
13935 
      oprot.writeI64(self.success)
13936 
      oprot.writeFieldEnd()
13937 
    oprot.writeFieldStop()
13938 
    oprot.writeStructEnd()
13939 
 
13940 
  def validate(self):
13941 
    return
13942 
 
13943 
 
13944 
  def __repr__(self):
13945 
    L = ['%s=%r' % (key, value)
13946 
      for key, value in self.__dict__.iteritems()]
13947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13948 
 
13949 
  def __eq__(self, other):
13950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13951 
 
13952 
  def __ne__(self, other):
13953 
    return not (self == other)
13954 
 
13955 
class validateRiskyStatus_args:
13956 
  """
13957 
  Attributes:
13958 
   - itemId
13959 
  """
13960 
 
13961 
  thrift_spec = (
13962 
    None, # 0
13963 
    (1, TType.I64, 'itemId', None, None, ), # 1
13964 
  )
13965 
 
13966 
  def __init__(self, itemId=None,):
13967 
    self.itemId = itemId
13968 
 
13969 
  def read(self, iprot):
13970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13972 
      return
13973 
    iprot.readStructBegin()
13974 
    while True:
13975 
      (fname, ftype, fid) = iprot.readFieldBegin()
13976 
      if ftype == TType.STOP:
13977 
        break
13978 
      if fid == 1:
13979 
        if ftype == TType.I64:
13980 
          self.itemId = iprot.readI64();
13981 
        else:
13982 
          iprot.skip(ftype)
13983 
      else:
13984 
        iprot.skip(ftype)
13985 
      iprot.readFieldEnd()
13986 
    iprot.readStructEnd()
13987 
 
13988 
  def write(self, oprot):
13989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13991 
      return
13992 
    oprot.writeStructBegin('validateRiskyStatus_args')
13993 
    if self.itemId is not None:
13994 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13995 
      oprot.writeI64(self.itemId)
13996 
      oprot.writeFieldEnd()
13997 
    oprot.writeFieldStop()
13998 
    oprot.writeStructEnd()
13999 
 
14000 
  def validate(self):
14001 
    return
14002 
 
14003 
 
14004 
  def __repr__(self):
14005 
    L = ['%s=%r' % (key, value)
14006 
      for key, value in self.__dict__.iteritems()]
14007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14008 
 
14009 
  def __eq__(self, other):
14010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14011 
 
14012 
  def __ne__(self, other):
14013 
    return not (self == other)
14014 
 
14015 
class validateRiskyStatus_result:
14016 
 
14017 
  thrift_spec = (
14018 
  )
14019 
 
14020 
  def read(self, iprot):
14021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14023 
      return
14024 
    iprot.readStructBegin()
14025 
    while True:
14026 
      (fname, ftype, fid) = iprot.readFieldBegin()
14027 
      if ftype == TType.STOP:
14028 
        break
14029 
      else:
14030 
        iprot.skip(ftype)
14031 
      iprot.readFieldEnd()
14032 
    iprot.readStructEnd()
14033 
 
14034 
  def write(self, oprot):
14035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14037 
      return
14038 
    oprot.writeStructBegin('validateRiskyStatus_result')
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
14057 
class changeItemRiskyFlag_args:
14058 
  """
14059 
  Attributes:
14060 
   - itemId
14061 
   - risky
14062 
  """
14063 
 
14064 
  thrift_spec = (
14065 
    None, # 0
14066 
    (1, TType.I64, 'itemId', None, None, ), # 1
14067 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14068 
  )
14069 
 
14070 
  def __init__(self, itemId=None, risky=None,):
14071 
    self.itemId = itemId
14072 
    self.risky = risky
14073 
 
14074 
  def read(self, iprot):
14075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14077 
      return
14078 
    iprot.readStructBegin()
14079 
    while True:
14080 
      (fname, ftype, fid) = iprot.readFieldBegin()
14081 
      if ftype == TType.STOP:
14082 
        break
14083 
      if fid == 1:
14084 
        if ftype == TType.I64:
14085 
          self.itemId = iprot.readI64();
14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      elif fid == 2:
14089 
        if ftype == TType.BOOL:
14090 
          self.risky = iprot.readBool();
14091 
        else:
14092 
          iprot.skip(ftype)
14093 
      else:
14094 
        iprot.skip(ftype)
14095 
      iprot.readFieldEnd()
14096 
    iprot.readStructEnd()
14097 
 
14098 
  def write(self, oprot):
14099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14101 
      return
14102 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14103 
    if self.itemId is not None:
14104 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14105 
      oprot.writeI64(self.itemId)
14106 
      oprot.writeFieldEnd()
14107 
    if self.risky is not None:
14108 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14109 
      oprot.writeBool(self.risky)
14110 
      oprot.writeFieldEnd()
14111 
    oprot.writeFieldStop()
14112 
    oprot.writeStructEnd()
14113 
 
14114 
  def validate(self):
14115 
    return
14116 
 
14117 
 
14118 
  def __repr__(self):
14119 
    L = ['%s=%r' % (key, value)
14120 
      for key, value in self.__dict__.iteritems()]
14121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14122 
 
14123 
  def __eq__(self, other):
14124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14125 
 
14126 
  def __ne__(self, other):
14127 
    return not (self == other)
14128 
 
14129 
class changeItemRiskyFlag_result:
14130 
 
14131 
  thrift_spec = (
14132 
  )
14133 
 
14134 
  def read(self, iprot):
14135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14137 
      return
14138 
    iprot.readStructBegin()
14139 
    while True:
14140 
      (fname, ftype, fid) = iprot.readFieldBegin()
14141 
      if ftype == TType.STOP:
14142 
        break
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
14152 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14153 
    oprot.writeFieldStop()
14154 
    oprot.writeStructEnd()
14155 
 
14156 
  def validate(self):
14157 
    return
14158 
 
14159 
 
14160 
  def __repr__(self):
14161 
    L = ['%s=%r' % (key, value)
14162 
      for key, value in self.__dict__.iteritems()]
14163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14164 
 
14165 
  def __eq__(self, other):
14166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14167 
 
14168 
  def __ne__(self, other):
14169 
    return not (self == other)
14170 
 
14171 
class getItemsByRiskyFlag_args:
14172 
 
14173 
  thrift_spec = (
14174 
  )
14175 
 
14176 
  def read(self, iprot):
14177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14179 
      return
14180 
    iprot.readStructBegin()
14181 
    while True:
14182 
      (fname, ftype, fid) = iprot.readFieldBegin()
14183 
      if ftype == TType.STOP:
14184 
        break
14185 
      else:
14186 
        iprot.skip(ftype)
14187 
      iprot.readFieldEnd()
14188 
    iprot.readStructEnd()
14189 
 
14190 
  def write(self, oprot):
14191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14193 
      return
14194 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14195 
    oprot.writeFieldStop()
14196 
    oprot.writeStructEnd()
14197 
 
14198 
  def validate(self):
14199 
    return
14200 
 
14201 
 
14202 
  def __repr__(self):
14203 
    L = ['%s=%r' % (key, value)
14204 
      for key, value in self.__dict__.iteritems()]
14205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14206 
 
14207 
  def __eq__(self, other):
14208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14209 
 
14210 
  def __ne__(self, other):
14211 
    return not (self == other)
14212 
 
14213 
class getItemsByRiskyFlag_result:
14214 
  """
14215 
  Attributes:
14216 
   - success
14217 
  """
14218 
 
14219 
  thrift_spec = (
14220 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14221 
  )
14222 
 
14223 
  def __init__(self, success=None,):
14224 
    self.success = success
14225 
 
14226 
  def read(self, iprot):
14227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14229 
      return
14230 
    iprot.readStructBegin()
14231 
    while True:
14232 
      (fname, ftype, fid) = iprot.readFieldBegin()
14233 
      if ftype == TType.STOP:
14234 
        break
14235 
      if fid == 0:
14236 
        if ftype == TType.LIST:
14237 
          self.success = []
8590 kshitij.so 14238 
          (_etype263, _size260) = iprot.readListBegin()
14239 
          for _i264 in xrange(_size260):
14240 
            _elem265 = Item()
14241 
            _elem265.read(iprot)
14242 
            self.success.append(_elem265)
5944 mandeep.dh 14243 
          iprot.readListEnd()
14244 
        else:
14245 
          iprot.skip(ftype)
14246 
      else:
14247 
        iprot.skip(ftype)
14248 
      iprot.readFieldEnd()
14249 
    iprot.readStructEnd()
14250 
 
14251 
  def write(self, oprot):
14252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14254 
      return
14255 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14256 
    if self.success is not None:
14257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14259 
      for iter266 in self.success:
14260 
        iter266.write(oprot)
5944 mandeep.dh 14261 
      oprot.writeListEnd()
14262 
      oprot.writeFieldEnd()
14263 
    oprot.writeFieldStop()
14264 
    oprot.writeStructEnd()
14265 
 
14266 
  def validate(self):
14267 
    return
14268 
 
14269 
 
14270 
  def __repr__(self):
14271 
    L = ['%s=%r' % (key, value)
14272 
      for key, value in self.__dict__.iteritems()]
14273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14274 
 
14275 
  def __eq__(self, other):
14276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14277 
 
14278 
  def __ne__(self, other):
14279 
    return not (self == other)
14280 
 
14281 
class getItemsForMasterSheet_args:
14282 
  """
14283 
  Attributes:
14284 
   - category
14285 
   - brand
14286 
  """
14287 
 
14288 
  thrift_spec = (
14289 
    None, # 0
14290 
    (1, TType.STRING, 'category', None, None, ), # 1
14291 
    (2, TType.STRING, 'brand', None, None, ), # 2
14292 
  )
14293 
 
14294 
  def __init__(self, category=None, brand=None,):
14295 
    self.category = category
14296 
    self.brand = brand
14297 
 
14298 
  def read(self, iprot):
14299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14301 
      return
14302 
    iprot.readStructBegin()
14303 
    while True:
14304 
      (fname, ftype, fid) = iprot.readFieldBegin()
14305 
      if ftype == TType.STOP:
14306 
        break
14307 
      if fid == 1:
14308 
        if ftype == TType.STRING:
14309 
          self.category = iprot.readString();
14310 
        else:
14311 
          iprot.skip(ftype)
14312 
      elif fid == 2:
14313 
        if ftype == TType.STRING:
14314 
          self.brand = iprot.readString();
14315 
        else:
14316 
          iprot.skip(ftype)
14317 
      else:
14318 
        iprot.skip(ftype)
14319 
      iprot.readFieldEnd()
14320 
    iprot.readStructEnd()
14321 
 
14322 
  def write(self, oprot):
14323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14325 
      return
14326 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14327 
    if self.category is not None:
14328 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14329 
      oprot.writeString(self.category)
14330 
      oprot.writeFieldEnd()
14331 
    if self.brand is not None:
14332 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14333 
      oprot.writeString(self.brand)
14334 
      oprot.writeFieldEnd()
14335 
    oprot.writeFieldStop()
14336 
    oprot.writeStructEnd()
14337 
 
14338 
  def validate(self):
14339 
    return
14340 
 
14341 
 
14342 
  def __repr__(self):
14343 
    L = ['%s=%r' % (key, value)
14344 
      for key, value in self.__dict__.iteritems()]
14345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14346 
 
14347 
  def __eq__(self, other):
14348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14349 
 
14350 
  def __ne__(self, other):
14351 
    return not (self == other)
14352 
 
14353 
class getItemsForMasterSheet_result:
14354 
  """
14355 
  Attributes:
14356 
   - success
14357 
  """
14358 
 
14359 
  thrift_spec = (
14360 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14361 
  )
14362 
 
14363 
  def __init__(self, success=None,):
14364 
    self.success = success
14365 
 
14366 
  def read(self, iprot):
14367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14369 
      return
14370 
    iprot.readStructBegin()
14371 
    while True:
14372 
      (fname, ftype, fid) = iprot.readFieldBegin()
14373 
      if ftype == TType.STOP:
14374 
        break
14375 
      if fid == 0:
14376 
        if ftype == TType.LIST:
14377 
          self.success = []
8590 kshitij.so 14378 
          (_etype270, _size267) = iprot.readListBegin()
14379 
          for _i271 in xrange(_size267):
14380 
            _elem272 = Item()
14381 
            _elem272.read(iprot)
14382 
            self.success.append(_elem272)
5944 mandeep.dh 14383 
          iprot.readListEnd()
14384 
        else:
14385 
          iprot.skip(ftype)
14386 
      else:
14387 
        iprot.skip(ftype)
14388 
      iprot.readFieldEnd()
14389 
    iprot.readStructEnd()
14390 
 
14391 
  def write(self, oprot):
14392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14394 
      return
14395 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14396 
    if self.success is not None:
14397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14399 
      for iter273 in self.success:
14400 
        iter273.write(oprot)
5944 mandeep.dh 14401 
      oprot.writeListEnd()
14402 
      oprot.writeFieldEnd()
14403 
    oprot.writeFieldStop()
14404 
    oprot.writeStructEnd()
14405 
 
14406 
  def validate(self):
14407 
    return
14408 
 
14409 
 
14410 
  def __repr__(self):
14411 
    L = ['%s=%r' % (key, value)
14412 
      for key, value in self.__dict__.iteritems()]
14413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14414 
 
14415 
  def __eq__(self, other):
14416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14417 
 
14418 
  def __ne__(self, other):
14419 
    return not (self == other)
14420 
 
14421 
class getSimilarItemsCatalogIds_args:
14422 
  """
14423 
  Attributes:
14424 
   - beginIndex
14425 
   - totalItems
14426 
   - itemId
14427 
  """
14428 
 
14429 
  thrift_spec = (
14430 
    None, # 0
14431 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14432 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14433 
    (3, TType.I64, 'itemId', None, None, ), # 3
14434 
  )
14435 
 
14436 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14437 
    self.beginIndex = beginIndex
14438 
    self.totalItems = totalItems
14439 
    self.itemId = itemId
14440 
 
14441 
  def read(self, iprot):
14442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14444 
      return
14445 
    iprot.readStructBegin()
14446 
    while True:
14447 
      (fname, ftype, fid) = iprot.readFieldBegin()
14448 
      if ftype == TType.STOP:
14449 
        break
14450 
      if fid == 1:
14451 
        if ftype == TType.I64:
14452 
          self.beginIndex = iprot.readI64();
14453 
        else:
14454 
          iprot.skip(ftype)
14455 
      elif fid == 2:
14456 
        if ftype == TType.I64:
14457 
          self.totalItems = iprot.readI64();
14458 
        else:
14459 
          iprot.skip(ftype)
14460 
      elif fid == 3:
14461 
        if ftype == TType.I64:
14462 
          self.itemId = iprot.readI64();
14463 
        else:
14464 
          iprot.skip(ftype)
14465 
      else:
14466 
        iprot.skip(ftype)
14467 
      iprot.readFieldEnd()
14468 
    iprot.readStructEnd()
14469 
 
14470 
  def write(self, oprot):
14471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14473 
      return
14474 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14475 
    if self.beginIndex is not None:
14476 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14477 
      oprot.writeI64(self.beginIndex)
14478 
      oprot.writeFieldEnd()
14479 
    if self.totalItems is not None:
14480 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14481 
      oprot.writeI64(self.totalItems)
14482 
      oprot.writeFieldEnd()
14483 
    if self.itemId is not None:
14484 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14485 
      oprot.writeI64(self.itemId)
14486 
      oprot.writeFieldEnd()
14487 
    oprot.writeFieldStop()
14488 
    oprot.writeStructEnd()
14489 
 
14490 
  def validate(self):
14491 
    return
14492 
 
14493 
 
14494 
  def __repr__(self):
14495 
    L = ['%s=%r' % (key, value)
14496 
      for key, value in self.__dict__.iteritems()]
14497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14498 
 
14499 
  def __eq__(self, other):
14500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14501 
 
14502 
  def __ne__(self, other):
14503 
    return not (self == other)
14504 
 
14505 
class getSimilarItemsCatalogIds_result:
14506 
  """
14507 
  Attributes:
14508 
   - success
14509 
  """
14510 
 
14511 
  thrift_spec = (
14512 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14513 
  )
14514 
 
14515 
  def __init__(self, success=None,):
14516 
    self.success = success
14517 
 
14518 
  def read(self, iprot):
14519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14521 
      return
14522 
    iprot.readStructBegin()
14523 
    while True:
14524 
      (fname, ftype, fid) = iprot.readFieldBegin()
14525 
      if ftype == TType.STOP:
14526 
        break
14527 
      if fid == 0:
14528 
        if ftype == TType.LIST:
14529 
          self.success = []
8590 kshitij.so 14530 
          (_etype277, _size274) = iprot.readListBegin()
14531 
          for _i278 in xrange(_size274):
14532 
            _elem279 = iprot.readI64();
14533 
            self.success.append(_elem279)
5944 mandeep.dh 14534 
          iprot.readListEnd()
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14547 
    if self.success is not None:
14548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14549 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 14550 
      for iter280 in self.success:
14551 
        oprot.writeI64(iter280)
5944 mandeep.dh 14552 
      oprot.writeListEnd()
14553 
      oprot.writeFieldEnd()
14554 
    oprot.writeFieldStop()
14555 
    oprot.writeStructEnd()
14556 
 
14557 
  def validate(self):
14558 
    return
14559 
 
14560 
 
14561 
  def __repr__(self):
14562 
    L = ['%s=%r' % (key, value)
14563 
      for key, value in self.__dict__.iteritems()]
14564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14565 
 
14566 
  def __eq__(self, other):
14567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14568 
 
14569 
  def __ne__(self, other):
14570 
    return not (self == other)
14571 
 
14572 
class addProductNotification_args:
14573 
  """
14574 
  Attributes:
14575 
   - itemId
14576 
   - email
14577 
  """
14578 
 
14579 
  thrift_spec = None
14580 
  def __init__(self, itemId=None, email=None,):
14581 
    self.itemId = itemId
14582 
    self.email = email
14583 
 
14584 
  def read(self, iprot):
14585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14587 
      return
14588 
    iprot.readStructBegin()
14589 
    while True:
14590 
      (fname, ftype, fid) = iprot.readFieldBegin()
14591 
      if ftype == TType.STOP:
14592 
        break
14593 
      if fid == -1:
14594 
        if ftype == TType.I64:
14595 
          self.itemId = iprot.readI64();
14596 
        else:
14597 
          iprot.skip(ftype)
14598 
      elif fid == -2:
14599 
        if ftype == TType.STRING:
14600 
          self.email = iprot.readString();
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('addProductNotification_args')
14613 
    if self.email is not None:
14614 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14615 
      oprot.writeString(self.email)
14616 
      oprot.writeFieldEnd()
14617 
    if self.itemId is not None:
14618 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14619 
      oprot.writeI64(self.itemId)
14620 
      oprot.writeFieldEnd()
14621 
    oprot.writeFieldStop()
14622 
    oprot.writeStructEnd()
14623 
 
14624 
  def validate(self):
14625 
    return
14626 
 
14627 
 
14628 
  def __repr__(self):
14629 
    L = ['%s=%r' % (key, value)
14630 
      for key, value in self.__dict__.iteritems()]
14631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14632 
 
14633 
  def __eq__(self, other):
14634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14635 
 
14636 
  def __ne__(self, other):
14637 
    return not (self == other)
14638 
 
14639 
class addProductNotification_result:
14640 
  """
14641 
  Attributes:
14642 
   - success
14643 
  """
14644 
 
14645 
  thrift_spec = (
14646 
    (0, TType.BOOL, 'success', None, None, ), # 0
14647 
  )
14648 
 
14649 
  def __init__(self, success=None,):
14650 
    self.success = success
14651 
 
14652 
  def read(self, iprot):
14653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14655 
      return
14656 
    iprot.readStructBegin()
14657 
    while True:
14658 
      (fname, ftype, fid) = iprot.readFieldBegin()
14659 
      if ftype == TType.STOP:
14660 
        break
14661 
      if fid == 0:
14662 
        if ftype == TType.BOOL:
14663 
          self.success = iprot.readBool();
14664 
        else:
14665 
          iprot.skip(ftype)
14666 
      else:
14667 
        iprot.skip(ftype)
14668 
      iprot.readFieldEnd()
14669 
    iprot.readStructEnd()
14670 
 
14671 
  def write(self, oprot):
14672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14674 
      return
14675 
    oprot.writeStructBegin('addProductNotification_result')
14676 
    if self.success is not None:
14677 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14678 
      oprot.writeBool(self.success)
14679 
      oprot.writeFieldEnd()
14680 
    oprot.writeFieldStop()
14681 
    oprot.writeStructEnd()
14682 
 
14683 
  def validate(self):
14684 
    return
14685 
 
14686 
 
14687 
  def __repr__(self):
14688 
    L = ['%s=%r' % (key, value)
14689 
      for key, value in self.__dict__.iteritems()]
14690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14691 
 
14692 
  def __eq__(self, other):
14693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14694 
 
14695 
  def __ne__(self, other):
14696 
    return not (self == other)
14697 
 
14698 
class sendProductNotifications_args:
14699 
 
14700 
  thrift_spec = (
14701 
  )
14702 
 
14703 
  def read(self, iprot):
14704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14706 
      return
14707 
    iprot.readStructBegin()
14708 
    while True:
14709 
      (fname, ftype, fid) = iprot.readFieldBegin()
14710 
      if ftype == TType.STOP:
14711 
        break
14712 
      else:
14713 
        iprot.skip(ftype)
14714 
      iprot.readFieldEnd()
14715 
    iprot.readStructEnd()
14716 
 
14717 
  def write(self, oprot):
14718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14720 
      return
14721 
    oprot.writeStructBegin('sendProductNotifications_args')
14722 
    oprot.writeFieldStop()
14723 
    oprot.writeStructEnd()
14724 
 
14725 
  def validate(self):
14726 
    return
14727 
 
14728 
 
14729 
  def __repr__(self):
14730 
    L = ['%s=%r' % (key, value)
14731 
      for key, value in self.__dict__.iteritems()]
14732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14733 
 
14734 
  def __eq__(self, other):
14735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14736 
 
14737 
  def __ne__(self, other):
14738 
    return not (self == other)
14739 
 
14740 
class sendProductNotifications_result:
14741 
  """
14742 
  Attributes:
14743 
   - success
14744 
  """
14745 
 
14746 
  thrift_spec = (
14747 
    (0, TType.BOOL, 'success', None, None, ), # 0
14748 
  )
14749 
 
14750 
  def __init__(self, success=None,):
14751 
    self.success = success
14752 
 
14753 
  def read(self, iprot):
14754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14756 
      return
14757 
    iprot.readStructBegin()
14758 
    while True:
14759 
      (fname, ftype, fid) = iprot.readFieldBegin()
14760 
      if ftype == TType.STOP:
14761 
        break
14762 
      if fid == 0:
14763 
        if ftype == TType.BOOL:
14764 
          self.success = iprot.readBool();
14765 
        else:
14766 
          iprot.skip(ftype)
14767 
      else:
14768 
        iprot.skip(ftype)
14769 
      iprot.readFieldEnd()
14770 
    iprot.readStructEnd()
14771 
 
14772 
  def write(self, oprot):
14773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14775 
      return
14776 
    oprot.writeStructBegin('sendProductNotifications_result')
14777 
    if self.success is not None:
14778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14779 
      oprot.writeBool(self.success)
14780 
      oprot.writeFieldEnd()
14781 
    oprot.writeFieldStop()
14782 
    oprot.writeStructEnd()
14783 
 
14784 
  def validate(self):
14785 
    return
14786 
 
14787 
 
14788 
  def __repr__(self):
14789 
    L = ['%s=%r' % (key, value)
14790 
      for key, value in self.__dict__.iteritems()]
14791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14792 
 
14793 
  def __eq__(self, other):
14794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14795 
 
14796 
  def __ne__(self, other):
14797 
    return not (self == other)
14798 
 
14799 
class getAllBrandsByCategory_args:
14800 
  """
14801 
  Attributes:
14802 
   - categoryId
14803 
  """
14804 
 
14805 
  thrift_spec = (
14806 
    None, # 0
14807 
    (1, TType.I64, 'categoryId', None, None, ), # 1
14808 
  )
14809 
 
14810 
  def __init__(self, categoryId=None,):
14811 
    self.categoryId = categoryId
14812 
 
14813 
  def read(self, iprot):
14814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14816 
      return
14817 
    iprot.readStructBegin()
14818 
    while True:
14819 
      (fname, ftype, fid) = iprot.readFieldBegin()
14820 
      if ftype == TType.STOP:
14821 
        break
14822 
      if fid == 1:
14823 
        if ftype == TType.I64:
14824 
          self.categoryId = iprot.readI64();
14825 
        else:
14826 
          iprot.skip(ftype)
14827 
      else:
14828 
        iprot.skip(ftype)
14829 
      iprot.readFieldEnd()
14830 
    iprot.readStructEnd()
14831 
 
14832 
  def write(self, oprot):
14833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14835 
      return
14836 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
14837 
    if self.categoryId is not None:
14838 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
14839 
      oprot.writeI64(self.categoryId)
14840 
      oprot.writeFieldEnd()
14841 
    oprot.writeFieldStop()
14842 
    oprot.writeStructEnd()
14843 
 
14844 
  def validate(self):
14845 
    return
14846 
 
14847 
 
14848 
  def __repr__(self):
14849 
    L = ['%s=%r' % (key, value)
14850 
      for key, value in self.__dict__.iteritems()]
14851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14852 
 
14853 
  def __eq__(self, other):
14854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14855 
 
14856 
  def __ne__(self, other):
14857 
    return not (self == other)
14858 
 
14859 
class getAllBrandsByCategory_result:
14860 
  """
14861 
  Attributes:
14862 
   - success
14863 
  """
14864 
 
14865 
  thrift_spec = (
14866 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14867 
  )
14868 
 
14869 
  def __init__(self, success=None,):
14870 
    self.success = success
14871 
 
14872 
  def read(self, iprot):
14873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14875 
      return
14876 
    iprot.readStructBegin()
14877 
    while True:
14878 
      (fname, ftype, fid) = iprot.readFieldBegin()
14879 
      if ftype == TType.STOP:
14880 
        break
14881 
      if fid == 0:
14882 
        if ftype == TType.LIST:
14883 
          self.success = []
8590 kshitij.so 14884 
          (_etype284, _size281) = iprot.readListBegin()
14885 
          for _i285 in xrange(_size281):
14886 
            _elem286 = iprot.readString();
14887 
            self.success.append(_elem286)
5944 mandeep.dh 14888 
          iprot.readListEnd()
14889 
        else:
14890 
          iprot.skip(ftype)
14891 
      else:
14892 
        iprot.skip(ftype)
14893 
      iprot.readFieldEnd()
14894 
    iprot.readStructEnd()
14895 
 
14896 
  def write(self, oprot):
14897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14899 
      return
14900 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
14901 
    if self.success is not None:
14902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14903 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14904 
      for iter287 in self.success:
14905 
        oprot.writeString(iter287)
5944 mandeep.dh 14906 
      oprot.writeListEnd()
14907 
      oprot.writeFieldEnd()
14908 
    oprot.writeFieldStop()
14909 
    oprot.writeStructEnd()
14910 
 
14911 
  def validate(self):
14912 
    return
14913 
 
14914 
 
14915 
  def __repr__(self):
14916 
    L = ['%s=%r' % (key, value)
14917 
      for key, value in self.__dict__.iteritems()]
14918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14919 
 
14920 
  def __eq__(self, other):
14921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14922 
 
14923 
  def __ne__(self, other):
14924 
    return not (self == other)
14925 
 
14926 
class getAllBrands_args:
14927 
 
14928 
  thrift_spec = (
14929 
  )
14930 
 
14931 
  def read(self, iprot):
14932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14934 
      return
14935 
    iprot.readStructBegin()
14936 
    while True:
14937 
      (fname, ftype, fid) = iprot.readFieldBegin()
14938 
      if ftype == TType.STOP:
14939 
        break
14940 
      else:
14941 
        iprot.skip(ftype)
14942 
      iprot.readFieldEnd()
14943 
    iprot.readStructEnd()
14944 
 
14945 
  def write(self, oprot):
14946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14948 
      return
14949 
    oprot.writeStructBegin('getAllBrands_args')
14950 
    oprot.writeFieldStop()
14951 
    oprot.writeStructEnd()
14952 
 
14953 
  def validate(self):
14954 
    return
14955 
 
14956 
 
14957 
  def __repr__(self):
14958 
    L = ['%s=%r' % (key, value)
14959 
      for key, value in self.__dict__.iteritems()]
14960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14961 
 
14962 
  def __eq__(self, other):
14963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14964 
 
14965 
  def __ne__(self, other):
14966 
    return not (self == other)
14967 
 
14968 
class getAllBrands_result:
14969 
  """
14970 
  Attributes:
14971 
   - success
14972 
  """
14973 
 
14974 
  thrift_spec = (
14975 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14976 
  )
14977 
 
14978 
  def __init__(self, success=None,):
14979 
    self.success = success
14980 
 
14981 
  def read(self, iprot):
14982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14984 
      return
14985 
    iprot.readStructBegin()
14986 
    while True:
14987 
      (fname, ftype, fid) = iprot.readFieldBegin()
14988 
      if ftype == TType.STOP:
14989 
        break
14990 
      if fid == 0:
14991 
        if ftype == TType.LIST:
14992 
          self.success = []
8590 kshitij.so 14993 
          (_etype291, _size288) = iprot.readListBegin()
14994 
          for _i292 in xrange(_size288):
14995 
            _elem293 = iprot.readString();
14996 
            self.success.append(_elem293)
5944 mandeep.dh 14997 
          iprot.readListEnd()
14998 
        else:
14999 
          iprot.skip(ftype)
15000 
      else:
15001 
        iprot.skip(ftype)
15002 
      iprot.readFieldEnd()
15003 
    iprot.readStructEnd()
15004 
 
15005 
  def write(self, oprot):
15006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15008 
      return
15009 
    oprot.writeStructBegin('getAllBrands_result')
15010 
    if self.success is not None:
15011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15012 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15013 
      for iter294 in self.success:
15014 
        oprot.writeString(iter294)
5944 mandeep.dh 15015 
      oprot.writeListEnd()
15016 
      oprot.writeFieldEnd()
15017 
    oprot.writeFieldStop()
15018 
    oprot.writeStructEnd()
15019 
 
15020 
  def validate(self):
15021 
    return
15022 
 
15023 
 
15024 
  def __repr__(self):
15025 
    L = ['%s=%r' % (key, value)
15026 
      for key, value in self.__dict__.iteritems()]
15027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15028 
 
15029 
  def __eq__(self, other):
15030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15031 
 
15032 
  def __ne__(self, other):
15033 
    return not (self == other)
15034 
 
15035 
class getAllSources_args:
15036 
 
15037 
  thrift_spec = (
15038 
  )
15039 
 
15040 
  def read(self, iprot):
15041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15043 
      return
15044 
    iprot.readStructBegin()
15045 
    while True:
15046 
      (fname, ftype, fid) = iprot.readFieldBegin()
15047 
      if ftype == TType.STOP:
15048 
        break
15049 
      else:
15050 
        iprot.skip(ftype)
15051 
      iprot.readFieldEnd()
15052 
    iprot.readStructEnd()
15053 
 
15054 
  def write(self, oprot):
15055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15057 
      return
15058 
    oprot.writeStructBegin('getAllSources_args')
15059 
    oprot.writeFieldStop()
15060 
    oprot.writeStructEnd()
15061 
 
15062 
  def validate(self):
15063 
    return
15064 
 
15065 
 
15066 
  def __repr__(self):
15067 
    L = ['%s=%r' % (key, value)
15068 
      for key, value in self.__dict__.iteritems()]
15069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15070 
 
15071 
  def __eq__(self, other):
15072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15073 
 
15074 
  def __ne__(self, other):
15075 
    return not (self == other)
15076 
 
15077 
class getAllSources_result:
15078 
  """
15079 
  Attributes:
15080 
   - success
15081 
  """
15082 
 
15083 
  thrift_spec = (
15084 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15085 
  )
15086 
 
15087 
  def __init__(self, success=None,):
15088 
    self.success = success
15089 
 
15090 
  def read(self, iprot):
15091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15093 
      return
15094 
    iprot.readStructBegin()
15095 
    while True:
15096 
      (fname, ftype, fid) = iprot.readFieldBegin()
15097 
      if ftype == TType.STOP:
15098 
        break
15099 
      if fid == 0:
15100 
        if ftype == TType.LIST:
15101 
          self.success = []
8590 kshitij.so 15102 
          (_etype298, _size295) = iprot.readListBegin()
15103 
          for _i299 in xrange(_size295):
15104 
            _elem300 = Source()
15105 
            _elem300.read(iprot)
15106 
            self.success.append(_elem300)
5944 mandeep.dh 15107 
          iprot.readListEnd()
15108 
        else:
15109 
          iprot.skip(ftype)
15110 
      else:
15111 
        iprot.skip(ftype)
15112 
      iprot.readFieldEnd()
15113 
    iprot.readStructEnd()
15114 
 
15115 
  def write(self, oprot):
15116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15118 
      return
15119 
    oprot.writeStructBegin('getAllSources_result')
15120 
    if self.success is not None:
15121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15122 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15123 
      for iter301 in self.success:
15124 
        iter301.write(oprot)
5944 mandeep.dh 15125 
      oprot.writeListEnd()
15126 
      oprot.writeFieldEnd()
15127 
    oprot.writeFieldStop()
15128 
    oprot.writeStructEnd()
15129 
 
15130 
  def validate(self):
15131 
    return
15132 
 
15133 
 
15134 
  def __repr__(self):
15135 
    L = ['%s=%r' % (key, value)
15136 
      for key, value in self.__dict__.iteritems()]
15137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15138 
 
15139 
  def __eq__(self, other):
15140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15141 
 
15142 
  def __ne__(self, other):
15143 
    return not (self == other)
15144 
 
15145 
class getItemPricingBySource_args:
15146 
  """
15147 
  Attributes:
15148 
   - itemId
15149 
   - sourceId
15150 
  """
15151 
 
15152 
  thrift_spec = (
15153 
    None, # 0
15154 
    (1, TType.I64, 'itemId', None, None, ), # 1
15155 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15156 
  )
15157 
 
15158 
  def __init__(self, itemId=None, sourceId=None,):
15159 
    self.itemId = itemId
15160 
    self.sourceId = sourceId
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 1:
15172 
        if ftype == TType.I64:
15173 
          self.itemId = iprot.readI64();
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      elif fid == 2:
15177 
        if ftype == TType.I64:
15178 
          self.sourceId = iprot.readI64();
15179 
        else:
15180 
          iprot.skip(ftype)
15181 
      else:
15182 
        iprot.skip(ftype)
15183 
      iprot.readFieldEnd()
15184 
    iprot.readStructEnd()
15185 
 
15186 
  def write(self, oprot):
15187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15189 
      return
15190 
    oprot.writeStructBegin('getItemPricingBySource_args')
15191 
    if self.itemId is not None:
15192 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15193 
      oprot.writeI64(self.itemId)
15194 
      oprot.writeFieldEnd()
15195 
    if self.sourceId is not None:
15196 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15197 
      oprot.writeI64(self.sourceId)
15198 
      oprot.writeFieldEnd()
15199 
    oprot.writeFieldStop()
15200 
    oprot.writeStructEnd()
15201 
 
15202 
  def validate(self):
15203 
    return
15204 
 
15205 
 
15206 
  def __repr__(self):
15207 
    L = ['%s=%r' % (key, value)
15208 
      for key, value in self.__dict__.iteritems()]
15209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15210 
 
15211 
  def __eq__(self, other):
15212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15213 
 
15214 
  def __ne__(self, other):
15215 
    return not (self == other)
15216 
 
15217 
class getItemPricingBySource_result:
15218 
  """
15219 
  Attributes:
15220 
   - success
15221 
   - cex
15222 
  """
15223 
 
15224 
  thrift_spec = (
15225 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15226 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15227 
  )
15228 
 
15229 
  def __init__(self, success=None, cex=None,):
15230 
    self.success = success
15231 
    self.cex = cex
15232 
 
15233 
  def read(self, iprot):
15234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15236 
      return
15237 
    iprot.readStructBegin()
15238 
    while True:
15239 
      (fname, ftype, fid) = iprot.readFieldBegin()
15240 
      if ftype == TType.STOP:
15241 
        break
15242 
      if fid == 0:
15243 
        if ftype == TType.STRUCT:
15244 
          self.success = SourceItemPricing()
15245 
          self.success.read(iprot)
15246 
        else:
15247 
          iprot.skip(ftype)
15248 
      elif fid == 1:
15249 
        if ftype == TType.STRUCT:
15250 
          self.cex = CatalogServiceException()
15251 
          self.cex.read(iprot)
15252 
        else:
15253 
          iprot.skip(ftype)
15254 
      else:
15255 
        iprot.skip(ftype)
15256 
      iprot.readFieldEnd()
15257 
    iprot.readStructEnd()
15258 
 
15259 
  def write(self, oprot):
15260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15262 
      return
15263 
    oprot.writeStructBegin('getItemPricingBySource_result')
15264 
    if self.success is not None:
15265 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15266 
      self.success.write(oprot)
15267 
      oprot.writeFieldEnd()
15268 
    if self.cex is not None:
15269 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15270 
      self.cex.write(oprot)
15271 
      oprot.writeFieldEnd()
15272 
    oprot.writeFieldStop()
15273 
    oprot.writeStructEnd()
15274 
 
15275 
  def validate(self):
15276 
    return
15277 
 
15278 
 
15279 
  def __repr__(self):
15280 
    L = ['%s=%r' % (key, value)
15281 
      for key, value in self.__dict__.iteritems()]
15282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15283 
 
15284 
  def __eq__(self, other):
15285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15286 
 
15287 
  def __ne__(self, other):
15288 
    return not (self == other)
15289 
 
15290 
class addSourceItemPricing_args:
15291 
  """
15292 
  Attributes:
15293 
   - sourceItemPricing
15294 
  """
15295 
 
15296 
  thrift_spec = (
15297 
    None, # 0
15298 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15299 
  )
15300 
 
15301 
  def __init__(self, sourceItemPricing=None,):
15302 
    self.sourceItemPricing = sourceItemPricing
15303 
 
15304 
  def read(self, iprot):
15305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15307 
      return
15308 
    iprot.readStructBegin()
15309 
    while True:
15310 
      (fname, ftype, fid) = iprot.readFieldBegin()
15311 
      if ftype == TType.STOP:
15312 
        break
15313 
      if fid == 1:
15314 
        if ftype == TType.STRUCT:
15315 
          self.sourceItemPricing = SourceItemPricing()
15316 
          self.sourceItemPricing.read(iprot)
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('addSourceItemPricing_args')
15329 
    if self.sourceItemPricing is not None:
15330 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15331 
      self.sourceItemPricing.write(oprot)
15332 
      oprot.writeFieldEnd()
15333 
    oprot.writeFieldStop()
15334 
    oprot.writeStructEnd()
15335 
 
15336 
  def validate(self):
15337 
    return
15338 
 
15339 
 
15340 
  def __repr__(self):
15341 
    L = ['%s=%r' % (key, value)
15342 
      for key, value in self.__dict__.iteritems()]
15343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15344 
 
15345 
  def __eq__(self, other):
15346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15347 
 
15348 
  def __ne__(self, other):
15349 
    return not (self == other)
15350 
 
15351 
class addSourceItemPricing_result:
15352 
  """
15353 
  Attributes:
15354 
   - cex
15355 
  """
15356 
 
15357 
  thrift_spec = (
15358 
    None, # 0
15359 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15360 
  )
15361 
 
15362 
  def __init__(self, cex=None,):
15363 
    self.cex = cex
15364 
 
15365 
  def read(self, iprot):
15366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15368 
      return
15369 
    iprot.readStructBegin()
15370 
    while True:
15371 
      (fname, ftype, fid) = iprot.readFieldBegin()
15372 
      if ftype == TType.STOP:
15373 
        break
15374 
      if fid == 1:
15375 
        if ftype == TType.STRUCT:
15376 
          self.cex = CatalogServiceException()
15377 
          self.cex.read(iprot)
15378 
        else:
15379 
          iprot.skip(ftype)
15380 
      else:
15381 
        iprot.skip(ftype)
15382 
      iprot.readFieldEnd()
15383 
    iprot.readStructEnd()
15384 
 
15385 
  def write(self, oprot):
15386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15388 
      return
15389 
    oprot.writeStructBegin('addSourceItemPricing_result')
15390 
    if self.cex is not None:
15391 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15392 
      self.cex.write(oprot)
15393 
      oprot.writeFieldEnd()
15394 
    oprot.writeFieldStop()
15395 
    oprot.writeStructEnd()
15396 
 
15397 
  def validate(self):
15398 
    return
15399 
 
15400 
 
15401 
  def __repr__(self):
15402 
    L = ['%s=%r' % (key, value)
15403 
      for key, value in self.__dict__.iteritems()]
15404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15405 
 
15406 
  def __eq__(self, other):
15407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15408 
 
15409 
  def __ne__(self, other):
15410 
    return not (self == other)
15411 
 
15412 
class getAllSourcePricing_args:
15413 
  """
15414 
  Attributes:
15415 
   - itemId
15416 
  """
15417 
 
15418 
  thrift_spec = (
15419 
    None, # 0
15420 
    (1, TType.I64, 'itemId', None, None, ), # 1
15421 
  )
15422 
 
15423 
  def __init__(self, itemId=None,):
15424 
    self.itemId = itemId
15425 
 
15426 
  def read(self, iprot):
15427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15429 
      return
15430 
    iprot.readStructBegin()
15431 
    while True:
15432 
      (fname, ftype, fid) = iprot.readFieldBegin()
15433 
      if ftype == TType.STOP:
15434 
        break
15435 
      if fid == 1:
15436 
        if ftype == TType.I64:
15437 
          self.itemId = iprot.readI64();
15438 
        else:
15439 
          iprot.skip(ftype)
15440 
      else:
15441 
        iprot.skip(ftype)
15442 
      iprot.readFieldEnd()
15443 
    iprot.readStructEnd()
15444 
 
15445 
  def write(self, oprot):
15446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15448 
      return
15449 
    oprot.writeStructBegin('getAllSourcePricing_args')
15450 
    if self.itemId is not None:
15451 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15452 
      oprot.writeI64(self.itemId)
15453 
      oprot.writeFieldEnd()
15454 
    oprot.writeFieldStop()
15455 
    oprot.writeStructEnd()
15456 
 
15457 
  def validate(self):
15458 
    return
15459 
 
15460 
 
15461 
  def __repr__(self):
15462 
    L = ['%s=%r' % (key, value)
15463 
      for key, value in self.__dict__.iteritems()]
15464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15465 
 
15466 
  def __eq__(self, other):
15467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15468 
 
15469 
  def __ne__(self, other):
15470 
    return not (self == other)
15471 
 
15472 
class getAllSourcePricing_result:
15473 
  """
15474 
  Attributes:
15475 
   - success
15476 
   - cex
15477 
  """
15478 
 
15479 
  thrift_spec = (
15480 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15481 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15482 
  )
15483 
 
15484 
  def __init__(self, success=None, cex=None,):
15485 
    self.success = success
15486 
    self.cex = cex
15487 
 
15488 
  def read(self, iprot):
15489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15491 
      return
15492 
    iprot.readStructBegin()
15493 
    while True:
15494 
      (fname, ftype, fid) = iprot.readFieldBegin()
15495 
      if ftype == TType.STOP:
15496 
        break
15497 
      if fid == 0:
15498 
        if ftype == TType.LIST:
15499 
          self.success = []
8590 kshitij.so 15500 
          (_etype305, _size302) = iprot.readListBegin()
15501 
          for _i306 in xrange(_size302):
15502 
            _elem307 = SourceItemPricing()
15503 
            _elem307.read(iprot)
15504 
            self.success.append(_elem307)
5944 mandeep.dh 15505 
          iprot.readListEnd()
15506 
        else:
15507 
          iprot.skip(ftype)
15508 
      elif fid == 1:
15509 
        if ftype == TType.STRUCT:
15510 
          self.cex = CatalogServiceException()
15511 
          self.cex.read(iprot)
15512 
        else:
15513 
          iprot.skip(ftype)
15514 
      else:
15515 
        iprot.skip(ftype)
15516 
      iprot.readFieldEnd()
15517 
    iprot.readStructEnd()
15518 
 
15519 
  def write(self, oprot):
15520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15522 
      return
15523 
    oprot.writeStructBegin('getAllSourcePricing_result')
15524 
    if self.success is not None:
15525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15526 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15527 
      for iter308 in self.success:
15528 
        iter308.write(oprot)
5944 mandeep.dh 15529 
      oprot.writeListEnd()
15530 
      oprot.writeFieldEnd()
15531 
    if self.cex is not None:
15532 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15533 
      self.cex.write(oprot)
15534 
      oprot.writeFieldEnd()
15535 
    oprot.writeFieldStop()
15536 
    oprot.writeStructEnd()
15537 
 
15538 
  def validate(self):
15539 
    return
15540 
 
15541 
 
15542 
  def __repr__(self):
15543 
    L = ['%s=%r' % (key, value)
15544 
      for key, value in self.__dict__.iteritems()]
15545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15546 
 
15547 
  def __eq__(self, other):
15548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15549 
 
15550 
  def __ne__(self, other):
15551 
    return not (self == other)
15552 
 
15553 
class getItemForSource_args:
15554 
  """
15555 
  Attributes:
15556 
   - item_id
15557 
   - sourceId
15558 
  """
15559 
 
15560 
  thrift_spec = (
15561 
    None, # 0
15562 
    (1, TType.I64, 'item_id', None, None, ), # 1
15563 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15564 
  )
15565 
 
15566 
  def __init__(self, item_id=None, sourceId=None,):
15567 
    self.item_id = item_id
15568 
    self.sourceId = sourceId
15569 
 
15570 
  def read(self, iprot):
15571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15573 
      return
15574 
    iprot.readStructBegin()
15575 
    while True:
15576 
      (fname, ftype, fid) = iprot.readFieldBegin()
15577 
      if ftype == TType.STOP:
15578 
        break
15579 
      if fid == 1:
15580 
        if ftype == TType.I64:
15581 
          self.item_id = iprot.readI64();
15582 
        else:
15583 
          iprot.skip(ftype)
15584 
      elif fid == 2:
15585 
        if ftype == TType.I64:
15586 
          self.sourceId = iprot.readI64();
15587 
        else:
15588 
          iprot.skip(ftype)
15589 
      else:
15590 
        iprot.skip(ftype)
15591 
      iprot.readFieldEnd()
15592 
    iprot.readStructEnd()
15593 
 
15594 
  def write(self, oprot):
15595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15597 
      return
15598 
    oprot.writeStructBegin('getItemForSource_args')
15599 
    if self.item_id is not None:
15600 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15601 
      oprot.writeI64(self.item_id)
15602 
      oprot.writeFieldEnd()
15603 
    if self.sourceId is not None:
15604 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15605 
      oprot.writeI64(self.sourceId)
15606 
      oprot.writeFieldEnd()
15607 
    oprot.writeFieldStop()
15608 
    oprot.writeStructEnd()
15609 
 
15610 
  def validate(self):
15611 
    return
15612 
 
15613 
 
15614 
  def __repr__(self):
15615 
    L = ['%s=%r' % (key, value)
15616 
      for key, value in self.__dict__.iteritems()]
15617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15618 
 
15619 
  def __eq__(self, other):
15620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15621 
 
15622 
  def __ne__(self, other):
15623 
    return not (self == other)
15624 
 
15625 
class getItemForSource_result:
15626 
  """
15627 
  Attributes:
15628 
   - success
15629 
   - cex
15630 
  """
15631 
 
15632 
  thrift_spec = (
15633 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15634 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15635 
  )
15636 
 
15637 
  def __init__(self, success=None, cex=None,):
15638 
    self.success = success
15639 
    self.cex = cex
15640 
 
15641 
  def read(self, iprot):
15642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15644 
      return
15645 
    iprot.readStructBegin()
15646 
    while True:
15647 
      (fname, ftype, fid) = iprot.readFieldBegin()
15648 
      if ftype == TType.STOP:
15649 
        break
15650 
      if fid == 0:
15651 
        if ftype == TType.STRUCT:
15652 
          self.success = Item()
15653 
          self.success.read(iprot)
15654 
        else:
15655 
          iprot.skip(ftype)
15656 
      elif fid == 1:
15657 
        if ftype == TType.STRUCT:
15658 
          self.cex = CatalogServiceException()
15659 
          self.cex.read(iprot)
15660 
        else:
15661 
          iprot.skip(ftype)
15662 
      else:
15663 
        iprot.skip(ftype)
15664 
      iprot.readFieldEnd()
15665 
    iprot.readStructEnd()
15666 
 
15667 
  def write(self, oprot):
15668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15670 
      return
15671 
    oprot.writeStructBegin('getItemForSource_result')
15672 
    if self.success is not None:
15673 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15674 
      self.success.write(oprot)
15675 
      oprot.writeFieldEnd()
15676 
    if self.cex is not None:
15677 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15678 
      self.cex.write(oprot)
15679 
      oprot.writeFieldEnd()
15680 
    oprot.writeFieldStop()
15681 
    oprot.writeStructEnd()
15682 
 
15683 
  def validate(self):
15684 
    return
15685 
 
15686 
 
15687 
  def __repr__(self):
15688 
    L = ['%s=%r' % (key, value)
15689 
      for key, value in self.__dict__.iteritems()]
15690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15691 
 
15692 
  def __eq__(self, other):
15693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15694 
 
15695 
  def __ne__(self, other):
15696 
    return not (self == other)
15697 
 
15698 
class searchItemsInRange_args:
15699 
  """
15700 
  Attributes:
15701 
   - searchTerms
15702 
   - offset
15703 
   - limit
15704 
  """
15705 
 
15706 
  thrift_spec = (
15707 
    None, # 0
15708 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15709 
    (2, TType.I64, 'offset', None, None, ), # 2
15710 
    (3, TType.I64, 'limit', None, None, ), # 3
15711 
  )
15712 
 
15713 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
15714 
    self.searchTerms = searchTerms
15715 
    self.offset = offset
15716 
    self.limit = limit
15717 
 
15718 
  def read(self, iprot):
15719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15721 
      return
15722 
    iprot.readStructBegin()
15723 
    while True:
15724 
      (fname, ftype, fid) = iprot.readFieldBegin()
15725 
      if ftype == TType.STOP:
15726 
        break
15727 
      if fid == 1:
15728 
        if ftype == TType.LIST:
15729 
          self.searchTerms = []
8590 kshitij.so 15730 
          (_etype312, _size309) = iprot.readListBegin()
15731 
          for _i313 in xrange(_size309):
15732 
            _elem314 = iprot.readString();
15733 
            self.searchTerms.append(_elem314)
5944 mandeep.dh 15734 
          iprot.readListEnd()
15735 
        else:
15736 
          iprot.skip(ftype)
15737 
      elif fid == 2:
15738 
        if ftype == TType.I64:
15739 
          self.offset = iprot.readI64();
15740 
        else:
15741 
          iprot.skip(ftype)
15742 
      elif fid == 3:
15743 
        if ftype == TType.I64:
15744 
          self.limit = iprot.readI64();
15745 
        else:
15746 
          iprot.skip(ftype)
15747 
      else:
15748 
        iprot.skip(ftype)
15749 
      iprot.readFieldEnd()
15750 
    iprot.readStructEnd()
15751 
 
15752 
  def write(self, oprot):
15753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15755 
      return
15756 
    oprot.writeStructBegin('searchItemsInRange_args')
15757 
    if self.searchTerms is not None:
15758 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15759 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15760 
      for iter315 in self.searchTerms:
15761 
        oprot.writeString(iter315)
5944 mandeep.dh 15762 
      oprot.writeListEnd()
15763 
      oprot.writeFieldEnd()
15764 
    if self.offset is not None:
15765 
      oprot.writeFieldBegin('offset', TType.I64, 2)
15766 
      oprot.writeI64(self.offset)
15767 
      oprot.writeFieldEnd()
15768 
    if self.limit is not None:
15769 
      oprot.writeFieldBegin('limit', TType.I64, 3)
15770 
      oprot.writeI64(self.limit)
15771 
      oprot.writeFieldEnd()
15772 
    oprot.writeFieldStop()
15773 
    oprot.writeStructEnd()
15774 
 
15775 
  def validate(self):
15776 
    return
15777 
 
15778 
 
15779 
  def __repr__(self):
15780 
    L = ['%s=%r' % (key, value)
15781 
      for key, value in self.__dict__.iteritems()]
15782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15783 
 
15784 
  def __eq__(self, other):
15785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15786 
 
15787 
  def __ne__(self, other):
15788 
    return not (self == other)
15789 
 
15790 
class searchItemsInRange_result:
15791 
  """
15792 
  Attributes:
15793 
   - success
15794 
  """
15795 
 
15796 
  thrift_spec = (
15797 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15798 
  )
15799 
 
15800 
  def __init__(self, success=None,):
15801 
    self.success = success
15802 
 
15803 
  def read(self, iprot):
15804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15806 
      return
15807 
    iprot.readStructBegin()
15808 
    while True:
15809 
      (fname, ftype, fid) = iprot.readFieldBegin()
15810 
      if ftype == TType.STOP:
15811 
        break
15812 
      if fid == 0:
15813 
        if ftype == TType.LIST:
15814 
          self.success = []
8590 kshitij.so 15815 
          (_etype319, _size316) = iprot.readListBegin()
15816 
          for _i320 in xrange(_size316):
15817 
            _elem321 = Item()
15818 
            _elem321.read(iprot)
15819 
            self.success.append(_elem321)
5944 mandeep.dh 15820 
          iprot.readListEnd()
15821 
        else:
15822 
          iprot.skip(ftype)
15823 
      else:
15824 
        iprot.skip(ftype)
15825 
      iprot.readFieldEnd()
15826 
    iprot.readStructEnd()
15827 
 
15828 
  def write(self, oprot):
15829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15831 
      return
15832 
    oprot.writeStructBegin('searchItemsInRange_result')
15833 
    if self.success is not None:
15834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15836 
      for iter322 in self.success:
15837 
        iter322.write(oprot)
5944 mandeep.dh 15838 
      oprot.writeListEnd()
15839 
      oprot.writeFieldEnd()
15840 
    oprot.writeFieldStop()
15841 
    oprot.writeStructEnd()
15842 
 
15843 
  def validate(self):
15844 
    return
15845 
 
15846 
 
15847 
  def __repr__(self):
15848 
    L = ['%s=%r' % (key, value)
15849 
      for key, value in self.__dict__.iteritems()]
15850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15851 
 
15852 
  def __eq__(self, other):
15853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15854 
 
15855 
  def __ne__(self, other):
15856 
    return not (self == other)
15857 
 
15858 
class getSearchResultCount_args:
15859 
  """
15860 
  Attributes:
15861 
   - searchTerms
15862 
  """
15863 
 
15864 
  thrift_spec = (
15865 
    None, # 0
15866 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15867 
  )
15868 
 
15869 
  def __init__(self, searchTerms=None,):
15870 
    self.searchTerms = searchTerms
15871 
 
15872 
  def read(self, iprot):
15873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15875 
      return
15876 
    iprot.readStructBegin()
15877 
    while True:
15878 
      (fname, ftype, fid) = iprot.readFieldBegin()
15879 
      if ftype == TType.STOP:
15880 
        break
15881 
      if fid == 1:
15882 
        if ftype == TType.LIST:
15883 
          self.searchTerms = []
8590 kshitij.so 15884 
          (_etype326, _size323) = iprot.readListBegin()
15885 
          for _i327 in xrange(_size323):
15886 
            _elem328 = iprot.readString();
15887 
            self.searchTerms.append(_elem328)
5944 mandeep.dh 15888 
          iprot.readListEnd()
15889 
        else:
15890 
          iprot.skip(ftype)
15891 
      else:
15892 
        iprot.skip(ftype)
15893 
      iprot.readFieldEnd()
15894 
    iprot.readStructEnd()
15895 
 
15896 
  def write(self, oprot):
15897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15899 
      return
15900 
    oprot.writeStructBegin('getSearchResultCount_args')
15901 
    if self.searchTerms is not None:
15902 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15903 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15904 
      for iter329 in self.searchTerms:
15905 
        oprot.writeString(iter329)
5944 mandeep.dh 15906 
      oprot.writeListEnd()
15907 
      oprot.writeFieldEnd()
15908 
    oprot.writeFieldStop()
15909 
    oprot.writeStructEnd()
15910 
 
15911 
  def validate(self):
15912 
    return
15913 
 
15914 
 
15915 
  def __repr__(self):
15916 
    L = ['%s=%r' % (key, value)
15917 
      for key, value in self.__dict__.iteritems()]
15918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15919 
 
15920 
  def __eq__(self, other):
15921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15922 
 
15923 
  def __ne__(self, other):
15924 
    return not (self == other)
15925 
 
15926 
class getSearchResultCount_result:
15927 
  """
15928 
  Attributes:
15929 
   - success
15930 
  """
15931 
 
15932 
  thrift_spec = (
15933 
    (0, TType.I32, 'success', None, None, ), # 0
15934 
  )
15935 
 
15936 
  def __init__(self, success=None,):
15937 
    self.success = success
15938 
 
15939 
  def read(self, iprot):
15940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15942 
      return
15943 
    iprot.readStructBegin()
15944 
    while True:
15945 
      (fname, ftype, fid) = iprot.readFieldBegin()
15946 
      if ftype == TType.STOP:
15947 
        break
15948 
      if fid == 0:
15949 
        if ftype == TType.I32:
15950 
          self.success = iprot.readI32();
15951 
        else:
15952 
          iprot.skip(ftype)
15953 
      else:
15954 
        iprot.skip(ftype)
15955 
      iprot.readFieldEnd()
15956 
    iprot.readStructEnd()
15957 
 
15958 
  def write(self, oprot):
15959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15961 
      return
15962 
    oprot.writeStructBegin('getSearchResultCount_result')
15963 
    if self.success is not None:
15964 
      oprot.writeFieldBegin('success', TType.I32, 0)
15965 
      oprot.writeI32(self.success)
15966 
      oprot.writeFieldEnd()
15967 
    oprot.writeFieldStop()
15968 
    oprot.writeStructEnd()
15969 
 
15970 
  def validate(self):
15971 
    return
15972 
 
15973 
 
15974 
  def __repr__(self):
15975 
    L = ['%s=%r' % (key, value)
15976 
      for key, value in self.__dict__.iteritems()]
15977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15978 
 
15979 
  def __eq__(self, other):
15980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15981 
 
15982 
  def __ne__(self, other):
15983 
    return not (self == other)
15984 
 
15985 
class getProductNotifications_args:
15986 
  """
15987 
  Attributes:
15988 
   - startDateTime
15989 
  """
15990 
 
15991 
  thrift_spec = (
15992 
    None, # 0
15993 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
15994 
  )
15995 
 
15996 
  def __init__(self, startDateTime=None,):
15997 
    self.startDateTime = startDateTime
15998 
 
15999 
  def read(self, iprot):
16000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16002 
      return
16003 
    iprot.readStructBegin()
16004 
    while True:
16005 
      (fname, ftype, fid) = iprot.readFieldBegin()
16006 
      if ftype == TType.STOP:
16007 
        break
16008 
      if fid == 1:
16009 
        if ftype == TType.I64:
16010 
          self.startDateTime = iprot.readI64();
16011 
        else:
16012 
          iprot.skip(ftype)
16013 
      else:
16014 
        iprot.skip(ftype)
16015 
      iprot.readFieldEnd()
16016 
    iprot.readStructEnd()
16017 
 
16018 
  def write(self, oprot):
16019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16021 
      return
16022 
    oprot.writeStructBegin('getProductNotifications_args')
16023 
    if self.startDateTime is not None:
16024 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16025 
      oprot.writeI64(self.startDateTime)
16026 
      oprot.writeFieldEnd()
16027 
    oprot.writeFieldStop()
16028 
    oprot.writeStructEnd()
16029 
 
16030 
  def validate(self):
16031 
    return
16032 
 
16033 
 
16034 
  def __repr__(self):
16035 
    L = ['%s=%r' % (key, value)
16036 
      for key, value in self.__dict__.iteritems()]
16037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16038 
 
16039 
  def __eq__(self, other):
16040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16041 
 
16042 
  def __ne__(self, other):
16043 
    return not (self == other)
16044 
 
16045 
class getProductNotifications_result:
16046 
  """
16047 
  Attributes:
16048 
   - success
16049 
  """
16050 
 
16051 
  thrift_spec = (
16052 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16053 
  )
16054 
 
16055 
  def __init__(self, success=None,):
16056 
    self.success = success
16057 
 
16058 
  def read(self, iprot):
16059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16061 
      return
16062 
    iprot.readStructBegin()
16063 
    while True:
16064 
      (fname, ftype, fid) = iprot.readFieldBegin()
16065 
      if ftype == TType.STOP:
16066 
        break
16067 
      if fid == 0:
16068 
        if ftype == TType.LIST:
16069 
          self.success = []
8590 kshitij.so 16070 
          (_etype333, _size330) = iprot.readListBegin()
16071 
          for _i334 in xrange(_size330):
16072 
            _elem335 = ProductNotificationRequest()
16073 
            _elem335.read(iprot)
16074 
            self.success.append(_elem335)
5944 mandeep.dh 16075 
          iprot.readListEnd()
16076 
        else:
16077 
          iprot.skip(ftype)
16078 
      else:
16079 
        iprot.skip(ftype)
16080 
      iprot.readFieldEnd()
16081 
    iprot.readStructEnd()
16082 
 
16083 
  def write(self, oprot):
16084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16086 
      return
16087 
    oprot.writeStructBegin('getProductNotifications_result')
16088 
    if self.success is not None:
16089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16091 
      for iter336 in self.success:
16092 
        iter336.write(oprot)
5944 mandeep.dh 16093 
      oprot.writeListEnd()
16094 
      oprot.writeFieldEnd()
16095 
    oprot.writeFieldStop()
16096 
    oprot.writeStructEnd()
16097 
 
16098 
  def validate(self):
16099 
    return
16100 
 
16101 
 
16102 
  def __repr__(self):
16103 
    L = ['%s=%r' % (key, value)
16104 
      for key, value in self.__dict__.iteritems()]
16105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16106 
 
16107 
  def __eq__(self, other):
16108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16109 
 
16110 
  def __ne__(self, other):
16111 
    return not (self == other)
16112 
 
16113 
class getProductNotificationRequestCount_args:
16114 
  """
16115 
  Attributes:
16116 
   - startDateTime
7897 amar.kumar 16117 
   - categoryId
5944 mandeep.dh 16118 
  """
16119 
 
16120 
  thrift_spec = (
16121 
    None, # 0
16122 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16123 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16124 
  )
16125 
 
7897 amar.kumar 16126 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16127 
    self.startDateTime = startDateTime
7897 amar.kumar 16128 
    self.categoryId = categoryId
5944 mandeep.dh 16129 
 
16130 
  def read(self, iprot):
16131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16133 
      return
16134 
    iprot.readStructBegin()
16135 
    while True:
16136 
      (fname, ftype, fid) = iprot.readFieldBegin()
16137 
      if ftype == TType.STOP:
16138 
        break
16139 
      if fid == 1:
16140 
        if ftype == TType.I64:
16141 
          self.startDateTime = iprot.readI64();
16142 
        else:
16143 
          iprot.skip(ftype)
7897 amar.kumar 16144 
      elif fid == 2:
16145 
        if ftype == TType.I64:
16146 
          self.categoryId = iprot.readI64();
16147 
        else:
16148 
          iprot.skip(ftype)
5944 mandeep.dh 16149 
      else:
16150 
        iprot.skip(ftype)
16151 
      iprot.readFieldEnd()
16152 
    iprot.readStructEnd()
16153 
 
16154 
  def write(self, oprot):
16155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16157 
      return
16158 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16159 
    if self.startDateTime is not None:
16160 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16161 
      oprot.writeI64(self.startDateTime)
16162 
      oprot.writeFieldEnd()
7897 amar.kumar 16163 
    if self.categoryId is not None:
16164 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16165 
      oprot.writeI64(self.categoryId)
16166 
      oprot.writeFieldEnd()
5944 mandeep.dh 16167 
    oprot.writeFieldStop()
16168 
    oprot.writeStructEnd()
16169 
 
16170 
  def validate(self):
16171 
    return
16172 
 
16173 
 
16174 
  def __repr__(self):
16175 
    L = ['%s=%r' % (key, value)
16176 
      for key, value in self.__dict__.iteritems()]
16177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16178 
 
16179 
  def __eq__(self, other):
16180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16181 
 
16182 
  def __ne__(self, other):
16183 
    return not (self == other)
16184 
 
16185 
class getProductNotificationRequestCount_result:
16186 
  """
16187 
  Attributes:
16188 
   - success
16189 
  """
16190 
 
16191 
  thrift_spec = (
16192 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16193 
  )
16194 
 
16195 
  def __init__(self, success=None,):
16196 
    self.success = success
16197 
 
16198 
  def read(self, iprot):
16199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16201 
      return
16202 
    iprot.readStructBegin()
16203 
    while True:
16204 
      (fname, ftype, fid) = iprot.readFieldBegin()
16205 
      if ftype == TType.STOP:
16206 
        break
16207 
      if fid == 0:
16208 
        if ftype == TType.LIST:
16209 
          self.success = []
8590 kshitij.so 16210 
          (_etype340, _size337) = iprot.readListBegin()
16211 
          for _i341 in xrange(_size337):
16212 
            _elem342 = ProductNotificationRequestCount()
16213 
            _elem342.read(iprot)
16214 
            self.success.append(_elem342)
5944 mandeep.dh 16215 
          iprot.readListEnd()
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
16227 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16228 
    if self.success is not None:
16229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16231 
      for iter343 in self.success:
16232 
        iter343.write(oprot)
5944 mandeep.dh 16233 
      oprot.writeListEnd()
16234 
      oprot.writeFieldEnd()
16235 
    oprot.writeFieldStop()
16236 
    oprot.writeStructEnd()
16237 
 
16238 
  def validate(self):
16239 
    return
16240 
 
16241 
 
16242 
  def __repr__(self):
16243 
    L = ['%s=%r' % (key, value)
16244 
      for key, value in self.__dict__.iteritems()]
16245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16246 
 
16247 
  def __eq__(self, other):
16248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16249 
 
16250 
  def __ne__(self, other):
16251 
    return not (self == other)
16252 
 
16253 
class addAuthorizationLog_args:
16254 
  """
16255 
  Attributes:
16256 
   - itemId
16257 
   - username
16258 
   - reason
16259 
  """
16260 
 
16261 
  thrift_spec = (
16262 
    None, # 0
16263 
    (1, TType.I64, 'itemId', None, None, ), # 1
16264 
    (2, TType.STRING, 'username', None, None, ), # 2
16265 
    (3, TType.STRING, 'reason', None, None, ), # 3
16266 
  )
16267 
 
16268 
  def __init__(self, itemId=None, username=None, reason=None,):
16269 
    self.itemId = itemId
16270 
    self.username = username
16271 
    self.reason = reason
16272 
 
16273 
  def read(self, iprot):
16274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16276 
      return
16277 
    iprot.readStructBegin()
16278 
    while True:
16279 
      (fname, ftype, fid) = iprot.readFieldBegin()
16280 
      if ftype == TType.STOP:
16281 
        break
16282 
      if fid == 1:
16283 
        if ftype == TType.I64:
16284 
          self.itemId = iprot.readI64();
16285 
        else:
16286 
          iprot.skip(ftype)
16287 
      elif fid == 2:
16288 
        if ftype == TType.STRING:
16289 
          self.username = iprot.readString();
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      elif fid == 3:
16293 
        if ftype == TType.STRING:
16294 
          self.reason = iprot.readString();
16295 
        else:
16296 
          iprot.skip(ftype)
16297 
      else:
16298 
        iprot.skip(ftype)
16299 
      iprot.readFieldEnd()
16300 
    iprot.readStructEnd()
16301 
 
16302 
  def write(self, oprot):
16303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16305 
      return
16306 
    oprot.writeStructBegin('addAuthorizationLog_args')
16307 
    if self.itemId is not None:
16308 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16309 
      oprot.writeI64(self.itemId)
16310 
      oprot.writeFieldEnd()
16311 
    if self.username is not None:
16312 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16313 
      oprot.writeString(self.username)
16314 
      oprot.writeFieldEnd()
16315 
    if self.reason is not None:
16316 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16317 
      oprot.writeString(self.reason)
16318 
      oprot.writeFieldEnd()
16319 
    oprot.writeFieldStop()
16320 
    oprot.writeStructEnd()
16321 
 
16322 
  def validate(self):
16323 
    return
16324 
 
16325 
 
16326 
  def __repr__(self):
16327 
    L = ['%s=%r' % (key, value)
16328 
      for key, value in self.__dict__.iteritems()]
16329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16330 
 
16331 
  def __eq__(self, other):
16332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16333 
 
16334 
  def __ne__(self, other):
16335 
    return not (self == other)
16336 
 
16337 
class addAuthorizationLog_result:
16338 
  """
16339 
  Attributes:
16340 
   - success
16341 
   - cex
16342 
  """
16343 
 
16344 
  thrift_spec = (
16345 
    (0, TType.BOOL, 'success', None, None, ), # 0
16346 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16347 
  )
16348 
 
16349 
  def __init__(self, success=None, cex=None,):
16350 
    self.success = success
16351 
    self.cex = cex
16352 
 
16353 
  def read(self, iprot):
16354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16356 
      return
16357 
    iprot.readStructBegin()
16358 
    while True:
16359 
      (fname, ftype, fid) = iprot.readFieldBegin()
16360 
      if ftype == TType.STOP:
16361 
        break
16362 
      if fid == 0:
16363 
        if ftype == TType.BOOL:
16364 
          self.success = iprot.readBool();
16365 
        else:
16366 
          iprot.skip(ftype)
16367 
      elif fid == 1:
16368 
        if ftype == TType.STRUCT:
16369 
          self.cex = CatalogServiceException()
16370 
          self.cex.read(iprot)
16371 
        else:
16372 
          iprot.skip(ftype)
16373 
      else:
16374 
        iprot.skip(ftype)
16375 
      iprot.readFieldEnd()
16376 
    iprot.readStructEnd()
16377 
 
16378 
  def write(self, oprot):
16379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16381 
      return
16382 
    oprot.writeStructBegin('addAuthorizationLog_result')
16383 
    if self.success is not None:
16384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16385 
      oprot.writeBool(self.success)
16386 
      oprot.writeFieldEnd()
16387 
    if self.cex is not None:
16388 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16389 
      self.cex.write(oprot)
16390 
      oprot.writeFieldEnd()
16391 
    oprot.writeFieldStop()
16392 
    oprot.writeStructEnd()
16393 
 
16394 
  def validate(self):
16395 
    return
16396 
 
16397 
 
16398 
  def __repr__(self):
16399 
    L = ['%s=%r' % (key, value)
16400 
      for key, value in self.__dict__.iteritems()]
16401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16402 
 
16403 
  def __eq__(self, other):
16404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16405 
 
16406 
  def __ne__(self, other):
16407 
    return not (self == other)
16408 
 
16409 
class addupdateVoucherForItem_args:
16410 
  """
16411 
  Attributes:
16412 
   - catalog_item_id
16413 
   - voucherType
16414 
   - voucherAmount
16415 
  """
16416 
 
16417 
  thrift_spec = (
16418 
    None, # 0
16419 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16420 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16421 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16422 
  )
16423 
 
16424 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16425 
    self.catalog_item_id = catalog_item_id
16426 
    self.voucherType = voucherType
16427 
    self.voucherAmount = voucherAmount
16428 
 
16429 
  def read(self, iprot):
16430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16432 
      return
16433 
    iprot.readStructBegin()
16434 
    while True:
16435 
      (fname, ftype, fid) = iprot.readFieldBegin()
16436 
      if ftype == TType.STOP:
16437 
        break
16438 
      if fid == 1:
16439 
        if ftype == TType.I64:
16440 
          self.catalog_item_id = iprot.readI64();
16441 
        else:
16442 
          iprot.skip(ftype)
16443 
      elif fid == 2:
16444 
        if ftype == TType.I64:
16445 
          self.voucherType = iprot.readI64();
16446 
        else:
16447 
          iprot.skip(ftype)
16448 
      elif fid == 3:
16449 
        if ftype == TType.I64:
16450 
          self.voucherAmount = iprot.readI64();
16451 
        else:
16452 
          iprot.skip(ftype)
16453 
      else:
16454 
        iprot.skip(ftype)
16455 
      iprot.readFieldEnd()
16456 
    iprot.readStructEnd()
16457 
 
16458 
  def write(self, oprot):
16459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16461 
      return
16462 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16463 
    if self.catalog_item_id is not None:
16464 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16465 
      oprot.writeI64(self.catalog_item_id)
16466 
      oprot.writeFieldEnd()
16467 
    if self.voucherType is not None:
16468 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16469 
      oprot.writeI64(self.voucherType)
16470 
      oprot.writeFieldEnd()
16471 
    if self.voucherAmount is not None:
16472 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16473 
      oprot.writeI64(self.voucherAmount)
16474 
      oprot.writeFieldEnd()
16475 
    oprot.writeFieldStop()
16476 
    oprot.writeStructEnd()
16477 
 
16478 
  def validate(self):
16479 
    return
16480 
 
16481 
 
16482 
  def __repr__(self):
16483 
    L = ['%s=%r' % (key, value)
16484 
      for key, value in self.__dict__.iteritems()]
16485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16486 
 
16487 
  def __eq__(self, other):
16488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16489 
 
16490 
  def __ne__(self, other):
16491 
    return not (self == other)
16492 
 
16493 
class addupdateVoucherForItem_result:
16494 
  """
16495 
  Attributes:
16496 
   - success
16497 
   - cex
16498 
  """
16499 
 
16500 
  thrift_spec = (
16501 
    (0, TType.BOOL, 'success', None, None, ), # 0
16502 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16503 
  )
16504 
 
16505 
  def __init__(self, success=None, cex=None,):
16506 
    self.success = success
16507 
    self.cex = cex
16508 
 
16509 
  def read(self, iprot):
16510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16512 
      return
16513 
    iprot.readStructBegin()
16514 
    while True:
16515 
      (fname, ftype, fid) = iprot.readFieldBegin()
16516 
      if ftype == TType.STOP:
16517 
        break
16518 
      if fid == 0:
16519 
        if ftype == TType.BOOL:
16520 
          self.success = iprot.readBool();
16521 
        else:
16522 
          iprot.skip(ftype)
16523 
      elif fid == 1:
16524 
        if ftype == TType.STRUCT:
16525 
          self.cex = CatalogServiceException()
16526 
          self.cex.read(iprot)
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16539 
    if self.success is not None:
16540 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16541 
      oprot.writeBool(self.success)
16542 
      oprot.writeFieldEnd()
16543 
    if self.cex is not None:
16544 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16545 
      self.cex.write(oprot)
16546 
      oprot.writeFieldEnd()
16547 
    oprot.writeFieldStop()
16548 
    oprot.writeStructEnd()
16549 
 
16550 
  def validate(self):
16551 
    return
16552 
 
16553 
 
16554 
  def __repr__(self):
16555 
    L = ['%s=%r' % (key, value)
16556 
      for key, value in self.__dict__.iteritems()]
16557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16558 
 
16559 
  def __eq__(self, other):
16560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16561 
 
16562 
  def __ne__(self, other):
16563 
    return not (self == other)
16564 
 
16565 
class deleteVoucherForItem_args:
16566 
  """
16567 
  Attributes:
16568 
   - catalog_item_id
16569 
   - voucherType
16570 
  """
16571 
 
16572 
  thrift_spec = (
16573 
    None, # 0
16574 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16575 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16576 
  )
16577 
 
16578 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16579 
    self.catalog_item_id = catalog_item_id
16580 
    self.voucherType = voucherType
16581 
 
16582 
  def read(self, iprot):
16583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16585 
      return
16586 
    iprot.readStructBegin()
16587 
    while True:
16588 
      (fname, ftype, fid) = iprot.readFieldBegin()
16589 
      if ftype == TType.STOP:
16590 
        break
16591 
      if fid == 1:
16592 
        if ftype == TType.I64:
16593 
          self.catalog_item_id = iprot.readI64();
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      elif fid == 2:
16597 
        if ftype == TType.I64:
16598 
          self.voucherType = iprot.readI64();
16599 
        else:
16600 
          iprot.skip(ftype)
16601 
      else:
16602 
        iprot.skip(ftype)
16603 
      iprot.readFieldEnd()
16604 
    iprot.readStructEnd()
16605 
 
16606 
  def write(self, oprot):
16607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16609 
      return
16610 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16611 
    if self.catalog_item_id is not None:
16612 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16613 
      oprot.writeI64(self.catalog_item_id)
16614 
      oprot.writeFieldEnd()
16615 
    if self.voucherType is not None:
16616 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16617 
      oprot.writeI64(self.voucherType)
16618 
      oprot.writeFieldEnd()
16619 
    oprot.writeFieldStop()
16620 
    oprot.writeStructEnd()
16621 
 
16622 
  def validate(self):
16623 
    return
16624 
 
16625 
 
16626 
  def __repr__(self):
16627 
    L = ['%s=%r' % (key, value)
16628 
      for key, value in self.__dict__.iteritems()]
16629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16630 
 
16631 
  def __eq__(self, other):
16632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16633 
 
16634 
  def __ne__(self, other):
16635 
    return not (self == other)
16636 
 
16637 
class deleteVoucherForItem_result:
16638 
  """
16639 
  Attributes:
16640 
   - success
16641 
   - cex
16642 
  """
16643 
 
16644 
  thrift_spec = (
16645 
    (0, TType.BOOL, 'success', None, None, ), # 0
16646 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16647 
  )
16648 
 
16649 
  def __init__(self, success=None, cex=None,):
16650 
    self.success = success
16651 
    self.cex = cex
16652 
 
16653 
  def read(self, iprot):
16654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16656 
      return
16657 
    iprot.readStructBegin()
16658 
    while True:
16659 
      (fname, ftype, fid) = iprot.readFieldBegin()
16660 
      if ftype == TType.STOP:
16661 
        break
16662 
      if fid == 0:
16663 
        if ftype == TType.BOOL:
16664 
          self.success = iprot.readBool();
16665 
        else:
16666 
          iprot.skip(ftype)
16667 
      elif fid == 1:
16668 
        if ftype == TType.STRUCT:
16669 
          self.cex = CatalogServiceException()
16670 
          self.cex.read(iprot)
16671 
        else:
16672 
          iprot.skip(ftype)
16673 
      else:
16674 
        iprot.skip(ftype)
16675 
      iprot.readFieldEnd()
16676 
    iprot.readStructEnd()
16677 
 
16678 
  def write(self, oprot):
16679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16681 
      return
16682 
    oprot.writeStructBegin('deleteVoucherForItem_result')
16683 
    if self.success is not None:
16684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16685 
      oprot.writeBool(self.success)
16686 
      oprot.writeFieldEnd()
16687 
    if self.cex is not None:
16688 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16689 
      self.cex.write(oprot)
16690 
      oprot.writeFieldEnd()
16691 
    oprot.writeFieldStop()
16692 
    oprot.writeStructEnd()
16693 
 
16694 
  def validate(self):
16695 
    return
16696 
 
16697 
 
16698 
  def __repr__(self):
16699 
    L = ['%s=%r' % (key, value)
16700 
      for key, value in self.__dict__.iteritems()]
16701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16702 
 
16703 
  def __eq__(self, other):
16704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16705 
 
16706 
  def __ne__(self, other):
16707 
    return not (self == other)
16708 
 
16709 
class getVoucherAmount_args:
16710 
  """
16711 
  Attributes:
16712 
   - itemId
16713 
   - voucherType
16714 
  """
16715 
 
16716 
  thrift_spec = (
16717 
    None, # 0
16718 
    (1, TType.I64, 'itemId', None, None, ), # 1
16719 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16720 
  )
16721 
 
16722 
  def __init__(self, itemId=None, voucherType=None,):
16723 
    self.itemId = itemId
16724 
    self.voucherType = voucherType
16725 
 
16726 
  def read(self, iprot):
16727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16729 
      return
16730 
    iprot.readStructBegin()
16731 
    while True:
16732 
      (fname, ftype, fid) = iprot.readFieldBegin()
16733 
      if ftype == TType.STOP:
16734 
        break
16735 
      if fid == 1:
16736 
        if ftype == TType.I64:
16737 
          self.itemId = iprot.readI64();
16738 
        else:
16739 
          iprot.skip(ftype)
16740 
      elif fid == 2:
16741 
        if ftype == TType.I64:
16742 
          self.voucherType = iprot.readI64();
16743 
        else:
16744 
          iprot.skip(ftype)
16745 
      else:
16746 
        iprot.skip(ftype)
16747 
      iprot.readFieldEnd()
16748 
    iprot.readStructEnd()
16749 
 
16750 
  def write(self, oprot):
16751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16753 
      return
16754 
    oprot.writeStructBegin('getVoucherAmount_args')
16755 
    if self.itemId is not None:
16756 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16757 
      oprot.writeI64(self.itemId)
16758 
      oprot.writeFieldEnd()
16759 
    if self.voucherType is not None:
16760 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16761 
      oprot.writeI64(self.voucherType)
16762 
      oprot.writeFieldEnd()
16763 
    oprot.writeFieldStop()
16764 
    oprot.writeStructEnd()
16765 
 
16766 
  def validate(self):
16767 
    return
16768 
 
16769 
 
16770 
  def __repr__(self):
16771 
    L = ['%s=%r' % (key, value)
16772 
      for key, value in self.__dict__.iteritems()]
16773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16774 
 
16775 
  def __eq__(self, other):
16776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16777 
 
16778 
  def __ne__(self, other):
16779 
    return not (self == other)
16780 
 
16781 
class getVoucherAmount_result:
16782 
  """
16783 
  Attributes:
16784 
   - success
16785 
  """
16786 
 
16787 
  thrift_spec = (
16788 
    (0, TType.I64, 'success', None, None, ), # 0
16789 
  )
16790 
 
16791 
  def __init__(self, success=None,):
16792 
    self.success = success
16793 
 
16794 
  def read(self, iprot):
16795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16797 
      return
16798 
    iprot.readStructBegin()
16799 
    while True:
16800 
      (fname, ftype, fid) = iprot.readFieldBegin()
16801 
      if ftype == TType.STOP:
16802 
        break
16803 
      if fid == 0:
16804 
        if ftype == TType.I64:
16805 
          self.success = iprot.readI64();
16806 
        else:
16807 
          iprot.skip(ftype)
16808 
      else:
16809 
        iprot.skip(ftype)
16810 
      iprot.readFieldEnd()
16811 
    iprot.readStructEnd()
16812 
 
16813 
  def write(self, oprot):
16814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16816 
      return
16817 
    oprot.writeStructBegin('getVoucherAmount_result')
16818 
    if self.success is not None:
16819 
      oprot.writeFieldBegin('success', TType.I64, 0)
16820 
      oprot.writeI64(self.success)
16821 
      oprot.writeFieldEnd()
16822 
    oprot.writeFieldStop()
16823 
    oprot.writeStructEnd()
16824 
 
16825 
  def validate(self):
16826 
    return
16827 
 
16828 
 
16829 
  def __repr__(self):
16830 
    L = ['%s=%r' % (key, value)
16831 
      for key, value in self.__dict__.iteritems()]
16832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16833 
 
16834 
  def __eq__(self, other):
16835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16836 
 
16837 
  def __ne__(self, other):
16838 
    return not (self == other)
16839 
 
16840 
class getAllItemVouchers_args:
16841 
  """
16842 
  Attributes:
16843 
   - itemId
16844 
  """
16845 
 
16846 
  thrift_spec = (
16847 
    None, # 0
16848 
    (1, TType.I64, 'itemId', None, None, ), # 1
16849 
  )
16850 
 
16851 
  def __init__(self, itemId=None,):
16852 
    self.itemId = itemId
16853 
 
16854 
  def read(self, iprot):
16855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16857 
      return
16858 
    iprot.readStructBegin()
16859 
    while True:
16860 
      (fname, ftype, fid) = iprot.readFieldBegin()
16861 
      if ftype == TType.STOP:
16862 
        break
16863 
      if fid == 1:
16864 
        if ftype == TType.I64:
16865 
          self.itemId = iprot.readI64();
16866 
        else:
16867 
          iprot.skip(ftype)
16868 
      else:
16869 
        iprot.skip(ftype)
16870 
      iprot.readFieldEnd()
16871 
    iprot.readStructEnd()
16872 
 
16873 
  def write(self, oprot):
16874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16876 
      return
16877 
    oprot.writeStructBegin('getAllItemVouchers_args')
16878 
    if self.itemId is not None:
16879 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16880 
      oprot.writeI64(self.itemId)
16881 
      oprot.writeFieldEnd()
16882 
    oprot.writeFieldStop()
16883 
    oprot.writeStructEnd()
16884 
 
16885 
  def validate(self):
16886 
    return
16887 
 
16888 
 
16889 
  def __repr__(self):
16890 
    L = ['%s=%r' % (key, value)
16891 
      for key, value in self.__dict__.iteritems()]
16892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16893 
 
16894 
  def __eq__(self, other):
16895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16896 
 
16897 
  def __ne__(self, other):
16898 
    return not (self == other)
16899 
 
16900 
class getAllItemVouchers_result:
16901 
  """
16902 
  Attributes:
16903 
   - success
16904 
  """
16905 
 
16906 
  thrift_spec = (
16907 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
16908 
  )
16909 
 
16910 
  def __init__(self, success=None,):
16911 
    self.success = success
16912 
 
16913 
  def read(self, iprot):
16914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16916 
      return
16917 
    iprot.readStructBegin()
16918 
    while True:
16919 
      (fname, ftype, fid) = iprot.readFieldBegin()
16920 
      if ftype == TType.STOP:
16921 
        break
16922 
      if fid == 0:
16923 
        if ftype == TType.LIST:
16924 
          self.success = []
8590 kshitij.so 16925 
          (_etype347, _size344) = iprot.readListBegin()
16926 
          for _i348 in xrange(_size344):
16927 
            _elem349 = VoucherItemMapping()
16928 
            _elem349.read(iprot)
16929 
            self.success.append(_elem349)
5944 mandeep.dh 16930 
          iprot.readListEnd()
16931 
        else:
16932 
          iprot.skip(ftype)
16933 
      else:
16934 
        iprot.skip(ftype)
16935 
      iprot.readFieldEnd()
16936 
    iprot.readStructEnd()
16937 
 
16938 
  def write(self, oprot):
16939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16941 
      return
16942 
    oprot.writeStructBegin('getAllItemVouchers_result')
16943 
    if self.success is not None:
16944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16946 
      for iter350 in self.success:
16947 
        iter350.write(oprot)
5944 mandeep.dh 16948 
      oprot.writeListEnd()
16949 
      oprot.writeFieldEnd()
16950 
    oprot.writeFieldStop()
16951 
    oprot.writeStructEnd()
16952 
 
16953 
  def validate(self):
16954 
    return
16955 
 
16956 
 
16957 
  def __repr__(self):
16958 
    L = ['%s=%r' % (key, value)
16959 
      for key, value in self.__dict__.iteritems()]
16960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16961 
 
16962 
  def __eq__(self, other):
16963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16964 
 
16965 
  def __ne__(self, other):
16966 
    return not (self == other)
16967 
 
16968 
class isValidCatalogItemId_args:
16969 
  """
16970 
  Attributes:
16971 
   - catalog_item_id
16972 
  """
16973 
 
16974 
  thrift_spec = (
16975 
    None, # 0
16976 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16977 
  )
16978 
 
16979 
  def __init__(self, catalog_item_id=None,):
16980 
    self.catalog_item_id = catalog_item_id
16981 
 
16982 
  def read(self, iprot):
16983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16985 
      return
16986 
    iprot.readStructBegin()
16987 
    while True:
16988 
      (fname, ftype, fid) = iprot.readFieldBegin()
16989 
      if ftype == TType.STOP:
16990 
        break
16991 
      if fid == 1:
16992 
        if ftype == TType.I64:
16993 
          self.catalog_item_id = iprot.readI64();
16994 
        else:
16995 
          iprot.skip(ftype)
16996 
      else:
16997 
        iprot.skip(ftype)
16998 
      iprot.readFieldEnd()
16999 
    iprot.readStructEnd()
17000 
 
17001 
  def write(self, oprot):
17002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17004 
      return
17005 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17006 
    if self.catalog_item_id is not None:
17007 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17008 
      oprot.writeI64(self.catalog_item_id)
17009 
      oprot.writeFieldEnd()
17010 
    oprot.writeFieldStop()
17011 
    oprot.writeStructEnd()
17012 
 
17013 
  def validate(self):
17014 
    return
17015 
 
17016 
 
17017 
  def __repr__(self):
17018 
    L = ['%s=%r' % (key, value)
17019 
      for key, value in self.__dict__.iteritems()]
17020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17021 
 
17022 
  def __eq__(self, other):
17023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17024 
 
17025 
  def __ne__(self, other):
17026 
    return not (self == other)
17027 
 
17028 
class isValidCatalogItemId_result:
17029 
  """
17030 
  Attributes:
17031 
   - success
17032 
  """
17033 
 
17034 
  thrift_spec = (
17035 
    (0, TType.BOOL, 'success', None, None, ), # 0
17036 
  )
17037 
 
17038 
  def __init__(self, success=None,):
17039 
    self.success = success
17040 
 
17041 
  def read(self, iprot):
17042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17044 
      return
17045 
    iprot.readStructBegin()
17046 
    while True:
17047 
      (fname, ftype, fid) = iprot.readFieldBegin()
17048 
      if ftype == TType.STOP:
17049 
        break
17050 
      if fid == 0:
17051 
        if ftype == TType.BOOL:
17052 
          self.success = iprot.readBool();
17053 
        else:
17054 
          iprot.skip(ftype)
17055 
      else:
17056 
        iprot.skip(ftype)
17057 
      iprot.readFieldEnd()
17058 
    iprot.readStructEnd()
17059 
 
17060 
  def write(self, oprot):
17061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17063 
      return
17064 
    oprot.writeStructBegin('isValidCatalogItemId_result')
17065 
    if self.success is not None:
17066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17067 
      oprot.writeBool(self.success)
17068 
      oprot.writeFieldEnd()
17069 
    oprot.writeFieldStop()
17070 
    oprot.writeStructEnd()
17071 
 
17072 
  def validate(self):
17073 
    return
17074 
 
17075 
 
17076 
  def __repr__(self):
17077 
    L = ['%s=%r' % (key, value)
17078 
      for key, value in self.__dict__.iteritems()]
17079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17080 
 
17081 
  def __eq__(self, other):
17082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17083 
 
17084 
  def __ne__(self, other):
17085 
    return not (self == other)
6039 amit.gupta 17086 
 
17087 
class getVatPercentageForItem_args:
17088 
  """
17089 
  Attributes:
17090 
   - itemId
7330 amit.gupta 17091 
   - stateId
6039 amit.gupta 17092 
   - price
17093 
  """
17094 
 
17095 
  thrift_spec = (
17096 
    None, # 0
17097 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17098 
    (2, TType.I64, 'stateId', None, None, ), # 2
17099 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17100 
  )
17101 
 
7330 amit.gupta 17102 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17103 
    self.itemId = itemId
7330 amit.gupta 17104 
    self.stateId = stateId
6039 amit.gupta 17105 
    self.price = price
17106 
 
17107 
  def read(self, iprot):
17108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17110 
      return
17111 
    iprot.readStructBegin()
17112 
    while True:
17113 
      (fname, ftype, fid) = iprot.readFieldBegin()
17114 
      if ftype == TType.STOP:
17115 
        break
17116 
      if fid == 1:
17117 
        if ftype == TType.I64:
17118 
          self.itemId = iprot.readI64();
17119 
        else:
17120 
          iprot.skip(ftype)
17121 
      elif fid == 2:
7330 amit.gupta 17122 
        if ftype == TType.I64:
17123 
          self.stateId = iprot.readI64();
17124 
        else:
17125 
          iprot.skip(ftype)
17126 
      elif fid == 3:
6039 amit.gupta 17127 
        if ftype == TType.DOUBLE:
17128 
          self.price = iprot.readDouble();
17129 
        else:
17130 
          iprot.skip(ftype)
17131 
      else:
17132 
        iprot.skip(ftype)
17133 
      iprot.readFieldEnd()
17134 
    iprot.readStructEnd()
17135 
 
17136 
  def write(self, oprot):
17137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17139 
      return
17140 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17141 
    if self.itemId is not None:
17142 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17143 
      oprot.writeI64(self.itemId)
17144 
      oprot.writeFieldEnd()
7330 amit.gupta 17145 
    if self.stateId is not None:
17146 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17147 
      oprot.writeI64(self.stateId)
17148 
      oprot.writeFieldEnd()
6039 amit.gupta 17149 
    if self.price is not None:
7330 amit.gupta 17150 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17151 
      oprot.writeDouble(self.price)
17152 
      oprot.writeFieldEnd()
17153 
    oprot.writeFieldStop()
17154 
    oprot.writeStructEnd()
17155 
 
17156 
  def validate(self):
17157 
    return
17158 
 
17159 
 
17160 
  def __repr__(self):
17161 
    L = ['%s=%r' % (key, value)
17162 
      for key, value in self.__dict__.iteritems()]
17163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17164 
 
17165 
  def __eq__(self, other):
17166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17167 
 
17168 
  def __ne__(self, other):
17169 
    return not (self == other)
17170 
 
17171 
class getVatPercentageForItem_result:
17172 
  """
17173 
  Attributes:
17174 
   - success
7340 amit.gupta 17175 
   - cex
6039 amit.gupta 17176 
  """
17177 
 
17178 
  thrift_spec = (
17179 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17180 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17181 
  )
17182 
 
7340 amit.gupta 17183 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17184 
    self.success = success
7340 amit.gupta 17185 
    self.cex = cex
6039 amit.gupta 17186 
 
17187 
  def read(self, iprot):
17188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17190 
      return
17191 
    iprot.readStructBegin()
17192 
    while True:
17193 
      (fname, ftype, fid) = iprot.readFieldBegin()
17194 
      if ftype == TType.STOP:
17195 
        break
17196 
      if fid == 0:
17197 
        if ftype == TType.DOUBLE:
17198 
          self.success = iprot.readDouble();
17199 
        else:
17200 
          iprot.skip(ftype)
7340 amit.gupta 17201 
      elif fid == 1:
17202 
        if ftype == TType.STRUCT:
17203 
          self.cex = CatalogServiceException()
17204 
          self.cex.read(iprot)
17205 
        else:
17206 
          iprot.skip(ftype)
6039 amit.gupta 17207 
      else:
17208 
        iprot.skip(ftype)
17209 
      iprot.readFieldEnd()
17210 
    iprot.readStructEnd()
17211 
 
17212 
  def write(self, oprot):
17213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17215 
      return
17216 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17217 
    if self.success is not None:
17218 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17219 
      oprot.writeDouble(self.success)
17220 
      oprot.writeFieldEnd()
7340 amit.gupta 17221 
    if self.cex is not None:
17222 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17223 
      self.cex.write(oprot)
17224 
      oprot.writeFieldEnd()
6039 amit.gupta 17225 
    oprot.writeFieldStop()
17226 
    oprot.writeStructEnd()
17227 
 
17228 
  def validate(self):
17229 
    return
17230 
 
17231 
 
17232 
  def __repr__(self):
17233 
    L = ['%s=%r' % (key, value)
17234 
      for key, value in self.__dict__.iteritems()]
17235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17236 
 
17237 
  def __eq__(self, other):
17238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17239 
 
17240 
  def __ne__(self, other):
17241 
    return not (self == other)
17242 
 
17243 
class getVatAmountForItem_args:
17244 
  """
17245 
  Attributes:
17246 
   - itemId
17247 
   - price
17248 
  """
17249 
 
17250 
  thrift_spec = (
17251 
    None, # 0
17252 
    (1, TType.I64, 'itemId', None, None, ), # 1
17253 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17254 
  )
17255 
 
17256 
  def __init__(self, itemId=None, price=None,):
17257 
    self.itemId = itemId
17258 
    self.price = price
17259 
 
17260 
  def read(self, iprot):
17261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17263 
      return
17264 
    iprot.readStructBegin()
17265 
    while True:
17266 
      (fname, ftype, fid) = iprot.readFieldBegin()
17267 
      if ftype == TType.STOP:
17268 
        break
17269 
      if fid == 1:
17270 
        if ftype == TType.I64:
17271 
          self.itemId = iprot.readI64();
17272 
        else:
17273 
          iprot.skip(ftype)
17274 
      elif fid == 2:
17275 
        if ftype == TType.DOUBLE:
17276 
          self.price = iprot.readDouble();
17277 
        else:
17278 
          iprot.skip(ftype)
17279 
      else:
17280 
        iprot.skip(ftype)
17281 
      iprot.readFieldEnd()
17282 
    iprot.readStructEnd()
17283 
 
17284 
  def write(self, oprot):
17285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17287 
      return
17288 
    oprot.writeStructBegin('getVatAmountForItem_args')
17289 
    if self.itemId is not None:
17290 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17291 
      oprot.writeI64(self.itemId)
17292 
      oprot.writeFieldEnd()
17293 
    if self.price is not None:
17294 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17295 
      oprot.writeDouble(self.price)
17296 
      oprot.writeFieldEnd()
17297 
    oprot.writeFieldStop()
17298 
    oprot.writeStructEnd()
17299 
 
17300 
  def validate(self):
17301 
    return
17302 
 
17303 
 
17304 
  def __repr__(self):
17305 
    L = ['%s=%r' % (key, value)
17306 
      for key, value in self.__dict__.iteritems()]
17307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17308 
 
17309 
  def __eq__(self, other):
17310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17311 
 
17312 
  def __ne__(self, other):
17313 
    return not (self == other)
17314 
 
17315 
class getVatAmountForItem_result:
17316 
  """
17317 
  Attributes:
17318 
   - success
17319 
  """
17320 
 
17321 
  thrift_spec = (
17322 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17323 
  )
17324 
 
17325 
  def __init__(self, success=None,):
17326 
    self.success = success
17327 
 
17328 
  def read(self, iprot):
17329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17331 
      return
17332 
    iprot.readStructBegin()
17333 
    while True:
17334 
      (fname, ftype, fid) = iprot.readFieldBegin()
17335 
      if ftype == TType.STOP:
17336 
        break
17337 
      if fid == 0:
17338 
        if ftype == TType.DOUBLE:
17339 
          self.success = iprot.readDouble();
17340 
        else:
17341 
          iprot.skip(ftype)
17342 
      else:
17343 
        iprot.skip(ftype)
17344 
      iprot.readFieldEnd()
17345 
    iprot.readStructEnd()
17346 
 
17347 
  def write(self, oprot):
17348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17350 
      return
17351 
    oprot.writeStructBegin('getVatAmountForItem_result')
17352 
    if self.success is not None:
17353 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17354 
      oprot.writeDouble(self.success)
17355 
      oprot.writeFieldEnd()
17356 
    oprot.writeFieldStop()
17357 
    oprot.writeStructEnd()
17358 
 
17359 
  def validate(self):
17360 
    return
17361 
 
17362 
 
17363 
  def __repr__(self):
17364 
    L = ['%s=%r' % (key, value)
17365 
      for key, value in self.__dict__.iteritems()]
17366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17367 
 
17368 
  def __eq__(self, other):
17369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17370 
 
17371 
  def __ne__(self, other):
17372 
    return not (self == other)
6531 vikram.rag 17373 
 
17374 
class getAllIgnoredInventoryUpdateItemsList_args:
17375 
  """
17376 
  Attributes:
17377 
   - offset
17378 
   - limit
17379 
  """
17380 
 
17381 
  thrift_spec = (
17382 
    None, # 0
17383 
    (1, TType.I32, 'offset', None, None, ), # 1
17384 
    (2, TType.I32, 'limit', None, None, ), # 2
17385 
  )
17386 
 
17387 
  def __init__(self, offset=None, limit=None,):
17388 
    self.offset = offset
17389 
    self.limit = limit
17390 
 
17391 
  def read(self, iprot):
17392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17394 
      return
17395 
    iprot.readStructBegin()
17396 
    while True:
17397 
      (fname, ftype, fid) = iprot.readFieldBegin()
17398 
      if ftype == TType.STOP:
17399 
        break
17400 
      if fid == 1:
17401 
        if ftype == TType.I32:
17402 
          self.offset = iprot.readI32();
17403 
        else:
17404 
          iprot.skip(ftype)
17405 
      elif fid == 2:
17406 
        if ftype == TType.I32:
17407 
          self.limit = iprot.readI32();
17408 
        else:
17409 
          iprot.skip(ftype)
17410 
      else:
17411 
        iprot.skip(ftype)
17412 
      iprot.readFieldEnd()
17413 
    iprot.readStructEnd()
17414 
 
17415 
  def write(self, oprot):
17416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17418 
      return
17419 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17420 
    if self.offset is not None:
17421 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17422 
      oprot.writeI32(self.offset)
17423 
      oprot.writeFieldEnd()
17424 
    if self.limit is not None:
17425 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17426 
      oprot.writeI32(self.limit)
17427 
      oprot.writeFieldEnd()
17428 
    oprot.writeFieldStop()
17429 
    oprot.writeStructEnd()
17430 
 
17431 
  def validate(self):
17432 
    return
17433 
 
17434 
 
17435 
  def __repr__(self):
17436 
    L = ['%s=%r' % (key, value)
17437 
      for key, value in self.__dict__.iteritems()]
17438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17439 
 
17440 
  def __eq__(self, other):
17441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17442 
 
17443 
  def __ne__(self, other):
17444 
    return not (self == other)
17445 
 
17446 
class getAllIgnoredInventoryUpdateItemsList_result:
17447 
  """
17448 
  Attributes:
17449 
   - success
17450 
  """
17451 
 
17452 
  thrift_spec = (
17453 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17454 
  )
17455 
 
17456 
  def __init__(self, success=None,):
17457 
    self.success = success
17458 
 
17459 
  def read(self, iprot):
17460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17462 
      return
17463 
    iprot.readStructBegin()
17464 
    while True:
17465 
      (fname, ftype, fid) = iprot.readFieldBegin()
17466 
      if ftype == TType.STOP:
17467 
        break
17468 
      if fid == 0:
17469 
        if ftype == TType.LIST:
17470 
          self.success = []
8590 kshitij.so 17471 
          (_etype354, _size351) = iprot.readListBegin()
17472 
          for _i355 in xrange(_size351):
17473 
            _elem356 = Item()
17474 
            _elem356.read(iprot)
17475 
            self.success.append(_elem356)
6531 vikram.rag 17476 
          iprot.readListEnd()
17477 
        else:
17478 
          iprot.skip(ftype)
17479 
      else:
17480 
        iprot.skip(ftype)
17481 
      iprot.readFieldEnd()
17482 
    iprot.readStructEnd()
17483 
 
17484 
  def write(self, oprot):
17485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17487 
      return
17488 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17489 
    if self.success is not None:
17490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17491 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17492 
      for iter357 in self.success:
17493 
        iter357.write(oprot)
6531 vikram.rag 17494 
      oprot.writeListEnd()
17495 
      oprot.writeFieldEnd()
17496 
    oprot.writeFieldStop()
17497 
    oprot.writeStructEnd()
17498 
 
17499 
  def validate(self):
17500 
    return
17501 
 
17502 
 
17503 
  def __repr__(self):
17504 
    L = ['%s=%r' % (key, value)
17505 
      for key, value in self.__dict__.iteritems()]
17506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17507 
 
17508 
  def __eq__(self, other):
17509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17510 
 
17511 
  def __ne__(self, other):
17512 
    return not (self == other)
6805 anupam.sin 17513 
 
6821 amar.kumar 17514 
class getAllAliveItems_args:
17515 
 
17516 
  thrift_spec = (
17517 
  )
17518 
 
17519 
  def read(self, iprot):
17520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17522 
      return
17523 
    iprot.readStructBegin()
17524 
    while True:
17525 
      (fname, ftype, fid) = iprot.readFieldBegin()
17526 
      if ftype == TType.STOP:
17527 
        break
17528 
      else:
17529 
        iprot.skip(ftype)
17530 
      iprot.readFieldEnd()
17531 
    iprot.readStructEnd()
17532 
 
17533 
  def write(self, oprot):
17534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17536 
      return
17537 
    oprot.writeStructBegin('getAllAliveItems_args')
17538 
    oprot.writeFieldStop()
17539 
    oprot.writeStructEnd()
17540 
 
17541 
  def validate(self):
17542 
    return
17543 
 
17544 
 
17545 
  def __repr__(self):
17546 
    L = ['%s=%r' % (key, value)
17547 
      for key, value in self.__dict__.iteritems()]
17548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17549 
 
17550 
  def __eq__(self, other):
17551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17552 
 
17553 
  def __ne__(self, other):
17554 
    return not (self == other)
17555 
 
17556 
class getAllAliveItems_result:
17557 
  """
17558 
  Attributes:
17559 
   - success
17560 
  """
17561 
 
17562 
  thrift_spec = (
17563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17564 
  )
17565 
 
17566 
  def __init__(self, success=None,):
17567 
    self.success = success
17568 
 
17569 
  def read(self, iprot):
17570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17572 
      return
17573 
    iprot.readStructBegin()
17574 
    while True:
17575 
      (fname, ftype, fid) = iprot.readFieldBegin()
17576 
      if ftype == TType.STOP:
17577 
        break
17578 
      if fid == 0:
17579 
        if ftype == TType.LIST:
17580 
          self.success = []
8590 kshitij.so 17581 
          (_etype361, _size358) = iprot.readListBegin()
17582 
          for _i362 in xrange(_size358):
17583 
            _elem363 = Item()
17584 
            _elem363.read(iprot)
17585 
            self.success.append(_elem363)
6821 amar.kumar 17586 
          iprot.readListEnd()
17587 
        else:
17588 
          iprot.skip(ftype)
17589 
      else:
17590 
        iprot.skip(ftype)
17591 
      iprot.readFieldEnd()
17592 
    iprot.readStructEnd()
17593 
 
17594 
  def write(self, oprot):
17595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17597 
      return
17598 
    oprot.writeStructBegin('getAllAliveItems_result')
17599 
    if self.success is not None:
17600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17602 
      for iter364 in self.success:
17603 
        iter364.write(oprot)
6821 amar.kumar 17604 
      oprot.writeListEnd()
17605 
      oprot.writeFieldEnd()
17606 
    oprot.writeFieldStop()
17607 
    oprot.writeStructEnd()
17608 
 
17609 
  def validate(self):
17610 
    return
17611 
 
17612 
 
17613 
  def __repr__(self):
17614 
    L = ['%s=%r' % (key, value)
17615 
      for key, value in self.__dict__.iteritems()]
17616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17617 
 
17618 
  def __eq__(self, other):
17619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17620 
 
17621 
  def __ne__(self, other):
17622 
    return not (self == other)
17623 
 
6805 anupam.sin 17624 
class getInsuranceAmount_args:
17625 
  """
17626 
  Attributes:
17627 
   - itemId
6921 anupam.sin 17628 
   - price
6805 anupam.sin 17629 
   - insurerId
17630 
   - quantity
17631 
  """
17632 
 
17633 
  thrift_spec = (
17634 
    None, # 0
17635 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17636 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17637 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17638 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17639 
  )
17640 
 
6921 anupam.sin 17641 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 17642 
    self.itemId = itemId
6921 anupam.sin 17643 
    self.price = price
6805 anupam.sin 17644 
    self.insurerId = insurerId
17645 
    self.quantity = quantity
17646 
 
17647 
  def read(self, iprot):
17648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17650 
      return
17651 
    iprot.readStructBegin()
17652 
    while True:
17653 
      (fname, ftype, fid) = iprot.readFieldBegin()
17654 
      if ftype == TType.STOP:
17655 
        break
17656 
      if fid == 1:
17657 
        if ftype == TType.I64:
17658 
          self.itemId = iprot.readI64();
17659 
        else:
17660 
          iprot.skip(ftype)
17661 
      elif fid == 2:
6921 anupam.sin 17662 
        if ftype == TType.DOUBLE:
17663 
          self.price = iprot.readDouble();
17664 
        else:
17665 
          iprot.skip(ftype)
17666 
      elif fid == 3:
6805 anupam.sin 17667 
        if ftype == TType.I64:
17668 
          self.insurerId = iprot.readI64();
17669 
        else:
17670 
          iprot.skip(ftype)
6921 anupam.sin 17671 
      elif fid == 4:
6805 anupam.sin 17672 
        if ftype == TType.I64:
17673 
          self.quantity = iprot.readI64();
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      else:
17677 
        iprot.skip(ftype)
17678 
      iprot.readFieldEnd()
17679 
    iprot.readStructEnd()
17680 
 
17681 
  def write(self, oprot):
17682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17684 
      return
17685 
    oprot.writeStructBegin('getInsuranceAmount_args')
17686 
    if self.itemId is not None:
17687 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17688 
      oprot.writeI64(self.itemId)
17689 
      oprot.writeFieldEnd()
6921 anupam.sin 17690 
    if self.price is not None:
17691 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17692 
      oprot.writeDouble(self.price)
17693 
      oprot.writeFieldEnd()
6805 anupam.sin 17694 
    if self.insurerId is not None:
6921 anupam.sin 17695 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 17696 
      oprot.writeI64(self.insurerId)
17697 
      oprot.writeFieldEnd()
17698 
    if self.quantity is not None:
6921 anupam.sin 17699 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 17700 
      oprot.writeI64(self.quantity)
17701 
      oprot.writeFieldEnd()
17702 
    oprot.writeFieldStop()
17703 
    oprot.writeStructEnd()
17704 
 
17705 
  def validate(self):
17706 
    return
17707 
 
17708 
 
17709 
  def __repr__(self):
17710 
    L = ['%s=%r' % (key, value)
17711 
      for key, value in self.__dict__.iteritems()]
17712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17713 
 
17714 
  def __eq__(self, other):
17715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17716 
 
17717 
  def __ne__(self, other):
17718 
    return not (self == other)
17719 
 
17720 
class getInsuranceAmount_result:
17721 
  """
17722 
  Attributes:
17723 
   - success
17724 
  """
17725 
 
17726 
  thrift_spec = (
17727 
    (0, TType.I64, 'success', None, None, ), # 0
17728 
  )
17729 
 
17730 
  def __init__(self, success=None,):
17731 
    self.success = success
17732 
 
17733 
  def read(self, iprot):
17734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17736 
      return
17737 
    iprot.readStructBegin()
17738 
    while True:
17739 
      (fname, ftype, fid) = iprot.readFieldBegin()
17740 
      if ftype == TType.STOP:
17741 
        break
17742 
      if fid == 0:
17743 
        if ftype == TType.I64:
17744 
          self.success = iprot.readI64();
17745 
        else:
17746 
          iprot.skip(ftype)
17747 
      else:
17748 
        iprot.skip(ftype)
17749 
      iprot.readFieldEnd()
17750 
    iprot.readStructEnd()
17751 
 
17752 
  def write(self, oprot):
17753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17755 
      return
17756 
    oprot.writeStructBegin('getInsuranceAmount_result')
17757 
    if self.success is not None:
17758 
      oprot.writeFieldBegin('success', TType.I64, 0)
17759 
      oprot.writeI64(self.success)
17760 
      oprot.writeFieldEnd()
17761 
    oprot.writeFieldStop()
17762 
    oprot.writeStructEnd()
17763 
 
17764 
  def validate(self):
17765 
    return
17766 
 
17767 
 
17768 
  def __repr__(self):
17769 
    L = ['%s=%r' % (key, value)
17770 
      for key, value in self.__dict__.iteritems()]
17771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17772 
 
17773 
  def __eq__(self, other):
17774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17775 
 
17776 
  def __ne__(self, other):
17777 
    return not (self == other)
17778 
 
17779 
class getInsurer_args:
17780 
  """
17781 
  Attributes:
17782 
   - insurerId
17783 
  """
17784 
 
17785 
  thrift_spec = (
17786 
    None, # 0
17787 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17788 
  )
17789 
 
17790 
  def __init__(self, insurerId=None,):
17791 
    self.insurerId = insurerId
17792 
 
17793 
  def read(self, iprot):
17794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17796 
      return
17797 
    iprot.readStructBegin()
17798 
    while True:
17799 
      (fname, ftype, fid) = iprot.readFieldBegin()
17800 
      if ftype == TType.STOP:
17801 
        break
17802 
      if fid == 1:
17803 
        if ftype == TType.I64:
17804 
          self.insurerId = iprot.readI64();
17805 
        else:
17806 
          iprot.skip(ftype)
17807 
      else:
17808 
        iprot.skip(ftype)
17809 
      iprot.readFieldEnd()
17810 
    iprot.readStructEnd()
17811 
 
17812 
  def write(self, oprot):
17813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17815 
      return
17816 
    oprot.writeStructBegin('getInsurer_args')
17817 
    if self.insurerId is not None:
17818 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17819 
      oprot.writeI64(self.insurerId)
17820 
      oprot.writeFieldEnd()
17821 
    oprot.writeFieldStop()
17822 
    oprot.writeStructEnd()
17823 
 
17824 
  def validate(self):
17825 
    return
17826 
 
17827 
 
17828 
  def __repr__(self):
17829 
    L = ['%s=%r' % (key, value)
17830 
      for key, value in self.__dict__.iteritems()]
17831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17832 
 
17833 
  def __eq__(self, other):
17834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17835 
 
17836 
  def __ne__(self, other):
17837 
    return not (self == other)
17838 
 
17839 
class getInsurer_result:
17840 
  """
17841 
  Attributes:
17842 
   - success
17843 
  """
17844 
 
17845 
  thrift_spec = (
17846 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
17847 
  )
17848 
 
17849 
  def __init__(self, success=None,):
17850 
    self.success = success
17851 
 
17852 
  def read(self, iprot):
17853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17855 
      return
17856 
    iprot.readStructBegin()
17857 
    while True:
17858 
      (fname, ftype, fid) = iprot.readFieldBegin()
17859 
      if ftype == TType.STOP:
17860 
        break
17861 
      if fid == 0:
17862 
        if ftype == TType.STRUCT:
17863 
          self.success = Insurer()
17864 
          self.success.read(iprot)
17865 
        else:
17866 
          iprot.skip(ftype)
17867 
      else:
17868 
        iprot.skip(ftype)
17869 
      iprot.readFieldEnd()
17870 
    iprot.readStructEnd()
17871 
 
17872 
  def write(self, oprot):
17873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17875 
      return
17876 
    oprot.writeStructBegin('getInsurer_result')
17877 
    if self.success is not None:
17878 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17879 
      self.success.write(oprot)
17880 
      oprot.writeFieldEnd()
17881 
    oprot.writeFieldStop()
17882 
    oprot.writeStructEnd()
17883 
 
17884 
  def validate(self):
17885 
    return
17886 
 
17887 
 
17888 
  def __repr__(self):
17889 
    L = ['%s=%r' % (key, value)
17890 
      for key, value in self.__dict__.iteritems()]
17891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17892 
 
17893 
  def __eq__(self, other):
17894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17895 
 
17896 
  def __ne__(self, other):
17897 
    return not (self == other)
6838 vikram.rag 17898 
 
17899 
class getAllInsurers_args:
17900 
 
17901 
  thrift_spec = (
17902 
  )
17903 
 
17904 
  def read(self, iprot):
17905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17907 
      return
17908 
    iprot.readStructBegin()
17909 
    while True:
17910 
      (fname, ftype, fid) = iprot.readFieldBegin()
17911 
      if ftype == TType.STOP:
17912 
        break
17913 
      else:
17914 
        iprot.skip(ftype)
17915 
      iprot.readFieldEnd()
17916 
    iprot.readStructEnd()
17917 
 
17918 
  def write(self, oprot):
17919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17921 
      return
17922 
    oprot.writeStructBegin('getAllInsurers_args')
17923 
    oprot.writeFieldStop()
17924 
    oprot.writeStructEnd()
17925 
 
17926 
  def validate(self):
17927 
    return
17928 
 
17929 
 
17930 
  def __repr__(self):
17931 
    L = ['%s=%r' % (key, value)
17932 
      for key, value in self.__dict__.iteritems()]
17933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17934 
 
17935 
  def __eq__(self, other):
17936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17937 
 
17938 
  def __ne__(self, other):
17939 
    return not (self == other)
17940 
 
17941 
class getAllInsurers_result:
17942 
  """
17943 
  Attributes:
17944 
   - success
17945 
  """
17946 
 
17947 
  thrift_spec = (
17948 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
17949 
  )
17950 
 
17951 
  def __init__(self, success=None,):
17952 
    self.success = success
17953 
 
17954 
  def read(self, iprot):
17955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17957 
      return
17958 
    iprot.readStructBegin()
17959 
    while True:
17960 
      (fname, ftype, fid) = iprot.readFieldBegin()
17961 
      if ftype == TType.STOP:
17962 
        break
17963 
      if fid == 0:
17964 
        if ftype == TType.LIST:
17965 
          self.success = []
8590 kshitij.so 17966 
          (_etype368, _size365) = iprot.readListBegin()
17967 
          for _i369 in xrange(_size365):
17968 
            _elem370 = Insurer()
17969 
            _elem370.read(iprot)
17970 
            self.success.append(_elem370)
6838 vikram.rag 17971 
          iprot.readListEnd()
17972 
        else:
17973 
          iprot.skip(ftype)
17974 
      else:
17975 
        iprot.skip(ftype)
17976 
      iprot.readFieldEnd()
17977 
    iprot.readStructEnd()
17978 
 
17979 
  def write(self, oprot):
17980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17982 
      return
17983 
    oprot.writeStructBegin('getAllInsurers_result')
17984 
    if self.success is not None:
17985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17987 
      for iter371 in self.success:
17988 
        iter371.write(oprot)
6838 vikram.rag 17989 
      oprot.writeListEnd()
17990 
      oprot.writeFieldEnd()
17991 
    oprot.writeFieldStop()
17992 
    oprot.writeStructEnd()
17993 
 
17994 
  def validate(self):
17995 
    return
17996 
 
17997 
 
17998 
  def __repr__(self):
17999 
    L = ['%s=%r' % (key, value)
18000 
      for key, value in self.__dict__.iteritems()]
18001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18002 
 
18003 
  def __eq__(self, other):
18004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18005 
 
18006 
  def __ne__(self, other):
18007 
    return not (self == other)
6962 rajveer 18008 
 
18009 
class updateInsuranceDeclaredAmount_args:
18010 
  """
18011 
  Attributes:
18012 
   - insurerId
18013 
   - amount
18014 
  """
18015 
 
18016 
  thrift_spec = (
18017 
    None, # 0
18018 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18019 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18020 
  )
18021 
 
18022 
  def __init__(self, insurerId=None, amount=None,):
18023 
    self.insurerId = insurerId
18024 
    self.amount = amount
18025 
 
18026 
  def read(self, iprot):
18027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18029 
      return
18030 
    iprot.readStructBegin()
18031 
    while True:
18032 
      (fname, ftype, fid) = iprot.readFieldBegin()
18033 
      if ftype == TType.STOP:
18034 
        break
18035 
      if fid == 1:
18036 
        if ftype == TType.I64:
18037 
          self.insurerId = iprot.readI64();
18038 
        else:
18039 
          iprot.skip(ftype)
18040 
      elif fid == 2:
18041 
        if ftype == TType.DOUBLE:
18042 
          self.amount = iprot.readDouble();
18043 
        else:
18044 
          iprot.skip(ftype)
18045 
      else:
18046 
        iprot.skip(ftype)
18047 
      iprot.readFieldEnd()
18048 
    iprot.readStructEnd()
18049 
 
18050 
  def write(self, oprot):
18051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18053 
      return
18054 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18055 
    if self.insurerId is not None:
18056 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18057 
      oprot.writeI64(self.insurerId)
18058 
      oprot.writeFieldEnd()
18059 
    if self.amount is not None:
18060 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18061 
      oprot.writeDouble(self.amount)
18062 
      oprot.writeFieldEnd()
18063 
    oprot.writeFieldStop()
18064 
    oprot.writeStructEnd()
18065 
 
18066 
  def validate(self):
18067 
    return
18068 
 
18069 
 
18070 
  def __repr__(self):
18071 
    L = ['%s=%r' % (key, value)
18072 
      for key, value in self.__dict__.iteritems()]
18073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18074 
 
18075 
  def __eq__(self, other):
18076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18077 
 
18078 
  def __ne__(self, other):
18079 
    return not (self == other)
18080 
 
18081 
class updateInsuranceDeclaredAmount_result:
18082 
 
18083 
  thrift_spec = (
18084 
  )
18085 
 
18086 
  def read(self, iprot):
18087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18089 
      return
18090 
    iprot.readStructBegin()
18091 
    while True:
18092 
      (fname, ftype, fid) = iprot.readFieldBegin()
18093 
      if ftype == TType.STOP:
18094 
        break
18095 
      else:
18096 
        iprot.skip(ftype)
18097 
      iprot.readFieldEnd()
18098 
    iprot.readStructEnd()
18099 
 
18100 
  def write(self, oprot):
18101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18103 
      return
18104 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18105 
    oprot.writeFieldStop()
18106 
    oprot.writeStructEnd()
18107 
 
18108 
  def validate(self):
18109 
    return
18110 
 
18111 
 
18112 
  def __repr__(self):
18113 
    L = ['%s=%r' % (key, value)
18114 
      for key, value in self.__dict__.iteritems()]
18115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18116 
 
18117 
  def __eq__(self, other):
18118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18119 
 
18120 
  def __ne__(self, other):
18121 
    return not (self == other)
7190 amar.kumar 18122 
 
18123 
class getFreebieForItem_args:
18124 
  """
18125 
  Attributes:
18126 
   - itemId
18127 
  """
18128 
 
18129 
  thrift_spec = (
18130 
    None, # 0
18131 
    (1, TType.I64, 'itemId', None, None, ), # 1
18132 
  )
18133 
 
18134 
  def __init__(self, itemId=None,):
18135 
    self.itemId = itemId
18136 
 
18137 
  def read(self, iprot):
18138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18140 
      return
18141 
    iprot.readStructBegin()
18142 
    while True:
18143 
      (fname, ftype, fid) = iprot.readFieldBegin()
18144 
      if ftype == TType.STOP:
18145 
        break
18146 
      if fid == 1:
18147 
        if ftype == TType.I64:
18148 
          self.itemId = iprot.readI64();
18149 
        else:
18150 
          iprot.skip(ftype)
18151 
      else:
18152 
        iprot.skip(ftype)
18153 
      iprot.readFieldEnd()
18154 
    iprot.readStructEnd()
18155 
 
18156 
  def write(self, oprot):
18157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18159 
      return
18160 
    oprot.writeStructBegin('getFreebieForItem_args')
18161 
    if self.itemId is not None:
18162 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18163 
      oprot.writeI64(self.itemId)
18164 
      oprot.writeFieldEnd()
18165 
    oprot.writeFieldStop()
18166 
    oprot.writeStructEnd()
18167 
 
18168 
  def validate(self):
18169 
    return
18170 
 
18171 
 
18172 
  def __repr__(self):
18173 
    L = ['%s=%r' % (key, value)
18174 
      for key, value in self.__dict__.iteritems()]
18175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18176 
 
18177 
  def __eq__(self, other):
18178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18179 
 
18180 
  def __ne__(self, other):
18181 
    return not (self == other)
18182 
 
18183 
class getFreebieForItem_result:
18184 
  """
18185 
  Attributes:
18186 
   - success
18187 
  """
18188 
 
18189 
  thrift_spec = (
18190 
    (0, TType.I64, 'success', None, None, ), # 0
18191 
  )
18192 
 
18193 
  def __init__(self, success=None,):
18194 
    self.success = success
18195 
 
18196 
  def read(self, iprot):
18197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18199 
      return
18200 
    iprot.readStructBegin()
18201 
    while True:
18202 
      (fname, ftype, fid) = iprot.readFieldBegin()
18203 
      if ftype == TType.STOP:
18204 
        break
18205 
      if fid == 0:
18206 
        if ftype == TType.I64:
18207 
          self.success = iprot.readI64();
18208 
        else:
18209 
          iprot.skip(ftype)
18210 
      else:
18211 
        iprot.skip(ftype)
18212 
      iprot.readFieldEnd()
18213 
    iprot.readStructEnd()
18214 
 
18215 
  def write(self, oprot):
18216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18218 
      return
18219 
    oprot.writeStructBegin('getFreebieForItem_result')
18220 
    if self.success is not None:
18221 
      oprot.writeFieldBegin('success', TType.I64, 0)
18222 
      oprot.writeI64(self.success)
18223 
      oprot.writeFieldEnd()
18224 
    oprot.writeFieldStop()
18225 
    oprot.writeStructEnd()
18226 
 
18227 
  def validate(self):
18228 
    return
18229 
 
18230 
 
18231 
  def __repr__(self):
18232 
    L = ['%s=%r' % (key, value)
18233 
      for key, value in self.__dict__.iteritems()]
18234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18235 
 
18236 
  def __eq__(self, other):
18237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18238 
 
18239 
  def __ne__(self, other):
18240 
    return not (self == other)
18241 
 
18242 
class addOrUpdateFreebieForItem_args:
18243 
  """
18244 
  Attributes:
18245 
   - freebieItem
18246 
  """
18247 
 
18248 
  thrift_spec = (
18249 
    None, # 0
18250 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18251 
  )
18252 
 
18253 
  def __init__(self, freebieItem=None,):
18254 
    self.freebieItem = freebieItem
18255 
 
18256 
  def read(self, iprot):
18257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18259 
      return
18260 
    iprot.readStructBegin()
18261 
    while True:
18262 
      (fname, ftype, fid) = iprot.readFieldBegin()
18263 
      if ftype == TType.STOP:
18264 
        break
18265 
      if fid == 1:
18266 
        if ftype == TType.STRUCT:
18267 
          self.freebieItem = FreebieItem()
18268 
          self.freebieItem.read(iprot)
18269 
        else:
18270 
          iprot.skip(ftype)
18271 
      else:
18272 
        iprot.skip(ftype)
18273 
      iprot.readFieldEnd()
18274 
    iprot.readStructEnd()
18275 
 
18276 
  def write(self, oprot):
18277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18279 
      return
18280 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18281 
    if self.freebieItem is not None:
18282 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18283 
      self.freebieItem.write(oprot)
18284 
      oprot.writeFieldEnd()
18285 
    oprot.writeFieldStop()
18286 
    oprot.writeStructEnd()
18287 
 
18288 
  def validate(self):
18289 
    return
18290 
 
18291 
 
18292 
  def __repr__(self):
18293 
    L = ['%s=%r' % (key, value)
18294 
      for key, value in self.__dict__.iteritems()]
18295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18296 
 
18297 
  def __eq__(self, other):
18298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18299 
 
18300 
  def __ne__(self, other):
18301 
    return not (self == other)
18302 
 
18303 
class addOrUpdateFreebieForItem_result:
18304 
 
18305 
  thrift_spec = (
18306 
  )
18307 
 
18308 
  def read(self, iprot):
18309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18311 
      return
18312 
    iprot.readStructBegin()
18313 
    while True:
18314 
      (fname, ftype, fid) = iprot.readFieldBegin()
18315 
      if ftype == TType.STOP:
18316 
        break
18317 
      else:
18318 
        iprot.skip(ftype)
18319 
      iprot.readFieldEnd()
18320 
    iprot.readStructEnd()
18321 
 
18322 
  def write(self, oprot):
18323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18325 
      return
18326 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18327 
    oprot.writeFieldStop()
18328 
    oprot.writeStructEnd()
18329 
 
18330 
  def validate(self):
18331 
    return
18332 
 
18333 
 
18334 
  def __repr__(self):
18335 
    L = ['%s=%r' % (key, value)
18336 
      for key, value in self.__dict__.iteritems()]
18337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18338 
 
18339 
  def __eq__(self, other):
18340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18341 
 
18342 
  def __ne__(self, other):
18343 
    return not (self == other)
7256 rajveer 18344 
 
7272 amit.gupta 18345 
class addOrUpdateBrandInfo_args:
18346 
  """
18347 
  Attributes:
18348 
   - brandInfo
18349 
  """
18350 
 
18351 
  thrift_spec = (
18352 
    None, # 0
18353 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18354 
  )
18355 
 
18356 
  def __init__(self, brandInfo=None,):
18357 
    self.brandInfo = brandInfo
18358 
 
18359 
  def read(self, iprot):
18360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18362 
      return
18363 
    iprot.readStructBegin()
18364 
    while True:
18365 
      (fname, ftype, fid) = iprot.readFieldBegin()
18366 
      if ftype == TType.STOP:
18367 
        break
18368 
      if fid == 1:
18369 
        if ftype == TType.STRUCT:
18370 
          self.brandInfo = BrandInfo()
18371 
          self.brandInfo.read(iprot)
18372 
        else:
18373 
          iprot.skip(ftype)
18374 
      else:
18375 
        iprot.skip(ftype)
18376 
      iprot.readFieldEnd()
18377 
    iprot.readStructEnd()
18378 
 
18379 
  def write(self, oprot):
18380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18382 
      return
18383 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18384 
    if self.brandInfo is not None:
18385 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18386 
      self.brandInfo.write(oprot)
18387 
      oprot.writeFieldEnd()
18388 
    oprot.writeFieldStop()
18389 
    oprot.writeStructEnd()
18390 
 
18391 
  def validate(self):
18392 
    return
18393 
 
18394 
 
18395 
  def __repr__(self):
18396 
    L = ['%s=%r' % (key, value)
18397 
      for key, value in self.__dict__.iteritems()]
18398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18399 
 
18400 
  def __eq__(self, other):
18401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18402 
 
18403 
  def __ne__(self, other):
18404 
    return not (self == other)
18405 
 
18406 
class addOrUpdateBrandInfo_result:
18407 
 
18408 
  thrift_spec = (
18409 
  )
18410 
 
18411 
  def read(self, iprot):
18412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18414 
      return
18415 
    iprot.readStructBegin()
18416 
    while True:
18417 
      (fname, ftype, fid) = iprot.readFieldBegin()
18418 
      if ftype == TType.STOP:
18419 
        break
18420 
      else:
18421 
        iprot.skip(ftype)
18422 
      iprot.readFieldEnd()
18423 
    iprot.readStructEnd()
18424 
 
18425 
  def write(self, oprot):
18426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18428 
      return
18429 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18430 
    oprot.writeFieldStop()
18431 
    oprot.writeStructEnd()
18432 
 
18433 
  def validate(self):
18434 
    return
18435 
 
18436 
 
18437 
  def __repr__(self):
18438 
    L = ['%s=%r' % (key, value)
18439 
      for key, value in self.__dict__.iteritems()]
18440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18441 
 
18442 
  def __eq__(self, other):
18443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18444 
 
18445 
  def __ne__(self, other):
18446 
    return not (self == other)
18447 
 
18448 
class getBrandInfo_args:
18449 
 
18450 
  thrift_spec = (
18451 
  )
18452 
 
18453 
  def read(self, iprot):
18454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18456 
      return
18457 
    iprot.readStructBegin()
18458 
    while True:
18459 
      (fname, ftype, fid) = iprot.readFieldBegin()
18460 
      if ftype == TType.STOP:
18461 
        break
18462 
      else:
18463 
        iprot.skip(ftype)
18464 
      iprot.readFieldEnd()
18465 
    iprot.readStructEnd()
18466 
 
18467 
  def write(self, oprot):
18468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18470 
      return
18471 
    oprot.writeStructBegin('getBrandInfo_args')
18472 
    oprot.writeFieldStop()
18473 
    oprot.writeStructEnd()
18474 
 
18475 
  def validate(self):
18476 
    return
18477 
 
18478 
 
18479 
  def __repr__(self):
18480 
    L = ['%s=%r' % (key, value)
18481 
      for key, value in self.__dict__.iteritems()]
18482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18483 
 
18484 
  def __eq__(self, other):
18485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18486 
 
18487 
  def __ne__(self, other):
18488 
    return not (self == other)
18489 
 
18490 
class getBrandInfo_result:
18491 
  """
18492 
  Attributes:
18493 
   - success
18494 
  """
18495 
 
18496 
  thrift_spec = (
18497 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18498 
  )
18499 
 
18500 
  def __init__(self, success=None,):
18501 
    self.success = success
18502 
 
18503 
  def read(self, iprot):
18504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18506 
      return
18507 
    iprot.readStructBegin()
18508 
    while True:
18509 
      (fname, ftype, fid) = iprot.readFieldBegin()
18510 
      if ftype == TType.STOP:
18511 
        break
18512 
      if fid == 0:
18513 
        if ftype == TType.MAP:
18514 
          self.success = {}
8590 kshitij.so 18515 
          (_ktype373, _vtype374, _size372 ) = iprot.readMapBegin()
18516 
          for _i376 in xrange(_size372):
18517 
            _key377 = iprot.readString();
18518 
            _val378 = BrandInfo()
18519 
            _val378.read(iprot)
18520 
            self.success[_key377] = _val378
7272 amit.gupta 18521 
          iprot.readMapEnd()
18522 
        else:
18523 
          iprot.skip(ftype)
18524 
      else:
18525 
        iprot.skip(ftype)
18526 
      iprot.readFieldEnd()
18527 
    iprot.readStructEnd()
18528 
 
18529 
  def write(self, oprot):
18530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18532 
      return
18533 
    oprot.writeStructBegin('getBrandInfo_result')
18534 
    if self.success is not None:
18535 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18536 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
8590 kshitij.so 18537 
      for kiter379,viter380 in self.success.items():
18538 
        oprot.writeString(kiter379)
18539 
        viter380.write(oprot)
7272 amit.gupta 18540 
      oprot.writeMapEnd()
18541 
      oprot.writeFieldEnd()
18542 
    oprot.writeFieldStop()
18543 
    oprot.writeStructEnd()
18544 
 
18545 
  def validate(self):
18546 
    return
18547 
 
18548 
 
18549 
  def __repr__(self):
18550 
    L = ['%s=%r' % (key, value)
18551 
      for key, value in self.__dict__.iteritems()]
18552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18553 
 
18554 
  def __eq__(self, other):
18555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18556 
 
18557 
  def __ne__(self, other):
18558 
    return not (self == other)
18559 
 
7256 rajveer 18560 
class getStorePricing_args:
18561 
  """
18562 
  Attributes:
18563 
   - itemId
18564 
  """
18565 
 
18566 
  thrift_spec = (
18567 
    None, # 0
18568 
    (1, TType.I64, 'itemId', None, None, ), # 1
18569 
  )
18570 
 
18571 
  def __init__(self, itemId=None,):
18572 
    self.itemId = itemId
18573 
 
18574 
  def read(self, iprot):
18575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18577 
      return
18578 
    iprot.readStructBegin()
18579 
    while True:
18580 
      (fname, ftype, fid) = iprot.readFieldBegin()
18581 
      if ftype == TType.STOP:
18582 
        break
18583 
      if fid == 1:
18584 
        if ftype == TType.I64:
18585 
          self.itemId = iprot.readI64();
18586 
        else:
18587 
          iprot.skip(ftype)
18588 
      else:
18589 
        iprot.skip(ftype)
18590 
      iprot.readFieldEnd()
18591 
    iprot.readStructEnd()
18592 
 
18593 
  def write(self, oprot):
18594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18596 
      return
18597 
    oprot.writeStructBegin('getStorePricing_args')
18598 
    if self.itemId is not None:
18599 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18600 
      oprot.writeI64(self.itemId)
18601 
      oprot.writeFieldEnd()
18602 
    oprot.writeFieldStop()
18603 
    oprot.writeStructEnd()
18604 
 
18605 
  def validate(self):
18606 
    return
18607 
 
18608 
 
18609 
  def __repr__(self):
18610 
    L = ['%s=%r' % (key, value)
18611 
      for key, value in self.__dict__.iteritems()]
18612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18613 
 
18614 
  def __eq__(self, other):
18615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18616 
 
18617 
  def __ne__(self, other):
18618 
    return not (self == other)
18619 
 
18620 
class getStorePricing_result:
18621 
  """
18622 
  Attributes:
18623 
   - success
18624 
  """
18625 
 
18626 
  thrift_spec = (
18627 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18628 
  )
18629 
 
18630 
  def __init__(self, success=None,):
18631 
    self.success = success
18632 
 
18633 
  def read(self, iprot):
18634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18636 
      return
18637 
    iprot.readStructBegin()
18638 
    while True:
18639 
      (fname, ftype, fid) = iprot.readFieldBegin()
18640 
      if ftype == TType.STOP:
18641 
        break
18642 
      if fid == 0:
18643 
        if ftype == TType.STRUCT:
18644 
          self.success = StorePricing()
18645 
          self.success.read(iprot)
18646 
        else:
18647 
          iprot.skip(ftype)
18648 
      else:
18649 
        iprot.skip(ftype)
18650 
      iprot.readFieldEnd()
18651 
    iprot.readStructEnd()
18652 
 
18653 
  def write(self, oprot):
18654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18656 
      return
18657 
    oprot.writeStructBegin('getStorePricing_result')
18658 
    if self.success is not None:
18659 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18660 
      self.success.write(oprot)
18661 
      oprot.writeFieldEnd()
18662 
    oprot.writeFieldStop()
18663 
    oprot.writeStructEnd()
18664 
 
18665 
  def validate(self):
18666 
    return
18667 
 
18668 
 
18669 
  def __repr__(self):
18670 
    L = ['%s=%r' % (key, value)
18671 
      for key, value in self.__dict__.iteritems()]
18672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18673 
 
18674 
  def __eq__(self, other):
18675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18676 
 
18677 
  def __ne__(self, other):
18678 
    return not (self == other)
7265 rajveer 18679 
 
7306 rajveer 18680 
class getStorePricings_args:
18681 
  """
18682 
  Attributes:
18683 
   - itemIds
18684 
  """
18685 
 
18686 
  thrift_spec = (
18687 
    None, # 0
18688 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18689 
  )
18690 
 
18691 
  def __init__(self, itemIds=None,):
18692 
    self.itemIds = itemIds
18693 
 
18694 
  def read(self, iprot):
18695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18697 
      return
18698 
    iprot.readStructBegin()
18699 
    while True:
18700 
      (fname, ftype, fid) = iprot.readFieldBegin()
18701 
      if ftype == TType.STOP:
18702 
        break
18703 
      if fid == 1:
18704 
        if ftype == TType.LIST:
18705 
          self.itemIds = []
8590 kshitij.so 18706 
          (_etype384, _size381) = iprot.readListBegin()
18707 
          for _i385 in xrange(_size381):
18708 
            _elem386 = iprot.readI64();
18709 
            self.itemIds.append(_elem386)
7306 rajveer 18710 
          iprot.readListEnd()
18711 
        else:
18712 
          iprot.skip(ftype)
18713 
      else:
18714 
        iprot.skip(ftype)
18715 
      iprot.readFieldEnd()
18716 
    iprot.readStructEnd()
18717 
 
18718 
  def write(self, oprot):
18719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18721 
      return
18722 
    oprot.writeStructBegin('getStorePricings_args')
18723 
    if self.itemIds is not None:
18724 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18725 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 18726 
      for iter387 in self.itemIds:
18727 
        oprot.writeI64(iter387)
7306 rajveer 18728 
      oprot.writeListEnd()
18729 
      oprot.writeFieldEnd()
18730 
    oprot.writeFieldStop()
18731 
    oprot.writeStructEnd()
18732 
 
18733 
  def validate(self):
18734 
    return
18735 
 
18736 
 
18737 
  def __repr__(self):
18738 
    L = ['%s=%r' % (key, value)
18739 
      for key, value in self.__dict__.iteritems()]
18740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18741 
 
18742 
  def __eq__(self, other):
18743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18744 
 
18745 
  def __ne__(self, other):
18746 
    return not (self == other)
18747 
 
18748 
class getStorePricings_result:
18749 
  """
18750 
  Attributes:
18751 
   - success
18752 
  """
18753 
 
18754 
  thrift_spec = (
18755 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
18756 
  )
18757 
 
18758 
  def __init__(self, success=None,):
18759 
    self.success = success
18760 
 
18761 
  def read(self, iprot):
18762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18764 
      return
18765 
    iprot.readStructBegin()
18766 
    while True:
18767 
      (fname, ftype, fid) = iprot.readFieldBegin()
18768 
      if ftype == TType.STOP:
18769 
        break
18770 
      if fid == 0:
18771 
        if ftype == TType.LIST:
18772 
          self.success = []
8590 kshitij.so 18773 
          (_etype391, _size388) = iprot.readListBegin()
18774 
          for _i392 in xrange(_size388):
18775 
            _elem393 = StorePricing()
18776 
            _elem393.read(iprot)
18777 
            self.success.append(_elem393)
7306 rajveer 18778 
          iprot.readListEnd()
18779 
        else:
18780 
          iprot.skip(ftype)
18781 
      else:
18782 
        iprot.skip(ftype)
18783 
      iprot.readFieldEnd()
18784 
    iprot.readStructEnd()
18785 
 
18786 
  def write(self, oprot):
18787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18789 
      return
18790 
    oprot.writeStructBegin('getStorePricings_result')
18791 
    if self.success is not None:
18792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18794 
      for iter394 in self.success:
18795 
        iter394.write(oprot)
7306 rajveer 18796 
      oprot.writeListEnd()
18797 
      oprot.writeFieldEnd()
18798 
    oprot.writeFieldStop()
18799 
    oprot.writeStructEnd()
18800 
 
18801 
  def validate(self):
18802 
    return
18803 
 
18804 
 
18805 
  def __repr__(self):
18806 
    L = ['%s=%r' % (key, value)
18807 
      for key, value in self.__dict__.iteritems()]
18808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18809 
 
18810 
  def __eq__(self, other):
18811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18812 
 
18813 
  def __ne__(self, other):
18814 
    return not (self == other)
18815 
 
7265 rajveer 18816 
class updateStorePricing_args:
18817 
  """
18818 
  Attributes:
18819 
   - sp
7382 rajveer 18820 
   - allColors
7265 rajveer 18821 
  """
18822 
 
18823 
  thrift_spec = (
18824 
    None, # 0
18825 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 18826 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 18827 
  )
18828 
 
7382 rajveer 18829 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 18830 
    self.sp = sp
7382 rajveer 18831 
    self.allColors = allColors
7265 rajveer 18832 
 
18833 
  def read(self, iprot):
18834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18836 
      return
18837 
    iprot.readStructBegin()
18838 
    while True:
18839 
      (fname, ftype, fid) = iprot.readFieldBegin()
18840 
      if ftype == TType.STOP:
18841 
        break
18842 
      if fid == 1:
18843 
        if ftype == TType.STRUCT:
18844 
          self.sp = StorePricing()
18845 
          self.sp.read(iprot)
18846 
        else:
18847 
          iprot.skip(ftype)
7382 rajveer 18848 
      elif fid == 2:
18849 
        if ftype == TType.BOOL:
18850 
          self.allColors = iprot.readBool();
18851 
        else:
18852 
          iprot.skip(ftype)
7265 rajveer 18853 
      else:
18854 
        iprot.skip(ftype)
18855 
      iprot.readFieldEnd()
18856 
    iprot.readStructEnd()
18857 
 
18858 
  def write(self, oprot):
18859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18861 
      return
18862 
    oprot.writeStructBegin('updateStorePricing_args')
18863 
    if self.sp is not None:
18864 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
18865 
      self.sp.write(oprot)
18866 
      oprot.writeFieldEnd()
7382 rajveer 18867 
    if self.allColors is not None:
18868 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
18869 
      oprot.writeBool(self.allColors)
18870 
      oprot.writeFieldEnd()
7265 rajveer 18871 
    oprot.writeFieldStop()
18872 
    oprot.writeStructEnd()
18873 
 
18874 
  def validate(self):
18875 
    return
18876 
 
18877 
 
18878 
  def __repr__(self):
18879 
    L = ['%s=%r' % (key, value)
18880 
      for key, value in self.__dict__.iteritems()]
18881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18882 
 
18883 
  def __eq__(self, other):
18884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18885 
 
18886 
  def __ne__(self, other):
18887 
    return not (self == other)
18888 
 
18889 
class updateStorePricing_result:
18890 
 
18891 
  thrift_spec = (
18892 
  )
18893 
 
18894 
  def read(self, iprot):
18895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18897 
      return
18898 
    iprot.readStructBegin()
18899 
    while True:
18900 
      (fname, ftype, fid) = iprot.readFieldBegin()
18901 
      if ftype == TType.STOP:
18902 
        break
18903 
      else:
18904 
        iprot.skip(ftype)
18905 
      iprot.readFieldEnd()
18906 
    iprot.readStructEnd()
18907 
 
18908 
  def write(self, oprot):
18909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18911 
      return
18912 
    oprot.writeStructBegin('updateStorePricing_result')
18913 
    oprot.writeFieldStop()
18914 
    oprot.writeStructEnd()
18915 
 
18916 
  def validate(self):
18917 
    return
18918 
 
18919 
 
18920 
  def __repr__(self):
18921 
    L = ['%s=%r' % (key, value)
18922 
      for key, value in self.__dict__.iteritems()]
18923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18924 
 
18925 
  def __eq__(self, other):
18926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18927 
 
18928 
  def __ne__(self, other):
18929 
    return not (self == other)
7281 kshitij.so 18930 
 
18931 
class getAllAmazonListedItems_args:
18932 
 
18933 
  thrift_spec = (
18934 
  )
18935 
 
18936 
  def read(self, iprot):
18937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18939 
      return
18940 
    iprot.readStructBegin()
18941 
    while True:
18942 
      (fname, ftype, fid) = iprot.readFieldBegin()
18943 
      if ftype == TType.STOP:
18944 
        break
18945 
      else:
18946 
        iprot.skip(ftype)
18947 
      iprot.readFieldEnd()
18948 
    iprot.readStructEnd()
18949 
 
18950 
  def write(self, oprot):
18951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18953 
      return
18954 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
18955 
    oprot.writeFieldStop()
18956 
    oprot.writeStructEnd()
18957 
 
18958 
  def validate(self):
18959 
    return
18960 
 
18961 
 
18962 
  def __repr__(self):
18963 
    L = ['%s=%r' % (key, value)
18964 
      for key, value in self.__dict__.iteritems()]
18965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18966 
 
18967 
  def __eq__(self, other):
18968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18969 
 
18970 
  def __ne__(self, other):
18971 
    return not (self == other)
18972 
 
18973 
class getAllAmazonListedItems_result:
18974 
  """
18975 
  Attributes:
18976 
   - success
18977 
  """
18978 
 
18979 
  thrift_spec = (
18980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18981 
  )
18982 
 
18983 
  def __init__(self, success=None,):
18984 
    self.success = success
18985 
 
18986 
  def read(self, iprot):
18987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18989 
      return
18990 
    iprot.readStructBegin()
18991 
    while True:
18992 
      (fname, ftype, fid) = iprot.readFieldBegin()
18993 
      if ftype == TType.STOP:
18994 
        break
18995 
      if fid == 0:
18996 
        if ftype == TType.LIST:
18997 
          self.success = []
8590 kshitij.so 18998 
          (_etype398, _size395) = iprot.readListBegin()
18999 
          for _i399 in xrange(_size395):
19000 
            _elem400 = Amazonlisted()
19001 
            _elem400.read(iprot)
19002 
            self.success.append(_elem400)
7281 kshitij.so 19003 
          iprot.readListEnd()
19004 
        else:
19005 
          iprot.skip(ftype)
19006 
      else:
19007 
        iprot.skip(ftype)
19008 
      iprot.readFieldEnd()
19009 
    iprot.readStructEnd()
19010 
 
19011 
  def write(self, oprot):
19012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19014 
      return
19015 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19016 
    if self.success is not None:
19017 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19018 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19019 
      for iter401 in self.success:
19020 
        iter401.write(oprot)
7281 kshitij.so 19021 
      oprot.writeListEnd()
19022 
      oprot.writeFieldEnd()
19023 
    oprot.writeFieldStop()
19024 
    oprot.writeStructEnd()
19025 
 
19026 
  def validate(self):
19027 
    return
19028 
 
19029 
 
19030 
  def __repr__(self):
19031 
    L = ['%s=%r' % (key, value)
19032 
      for key, value in self.__dict__.iteritems()]
19033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19034 
 
19035 
  def __eq__(self, other):
19036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19037 
 
19038 
  def __ne__(self, other):
19039 
    return not (self == other)
19040 
 
8619 kshitij.so 19041 
class searchAmazonItems_args:
19042 
  """
19043 
  Attributes:
19044 
   - searchTerm
19045 
   - offset
19046 
   - limit
19047 
  """
19048 
 
19049 
  thrift_spec = (
19050 
    None, # 0
19051 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19052 
    (2, TType.I64, 'offset', None, None, ), # 2
19053 
    (3, TType.I64, 'limit', None, None, ), # 3
19054 
  )
19055 
 
19056 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19057 
    self.searchTerm = searchTerm
19058 
    self.offset = offset
19059 
    self.limit = limit
19060 
 
19061 
  def read(self, iprot):
19062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19064 
      return
19065 
    iprot.readStructBegin()
19066 
    while True:
19067 
      (fname, ftype, fid) = iprot.readFieldBegin()
19068 
      if ftype == TType.STOP:
19069 
        break
19070 
      if fid == 1:
19071 
        if ftype == TType.LIST:
19072 
          self.searchTerm = []
19073 
          (_etype405, _size402) = iprot.readListBegin()
19074 
          for _i406 in xrange(_size402):
19075 
            _elem407 = iprot.readString();
19076 
            self.searchTerm.append(_elem407)
19077 
          iprot.readListEnd()
19078 
        else:
19079 
          iprot.skip(ftype)
19080 
      elif fid == 2:
19081 
        if ftype == TType.I64:
19082 
          self.offset = iprot.readI64();
19083 
        else:
19084 
          iprot.skip(ftype)
19085 
      elif fid == 3:
19086 
        if ftype == TType.I64:
19087 
          self.limit = iprot.readI64();
19088 
        else:
19089 
          iprot.skip(ftype)
19090 
      else:
19091 
        iprot.skip(ftype)
19092 
      iprot.readFieldEnd()
19093 
    iprot.readStructEnd()
19094 
 
19095 
  def write(self, oprot):
19096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19098 
      return
19099 
    oprot.writeStructBegin('searchAmazonItems_args')
19100 
    if self.searchTerm is not None:
19101 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19102 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
19103 
      for iter408 in self.searchTerm:
19104 
        oprot.writeString(iter408)
19105 
      oprot.writeListEnd()
19106 
      oprot.writeFieldEnd()
19107 
    if self.offset is not None:
19108 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19109 
      oprot.writeI64(self.offset)
19110 
      oprot.writeFieldEnd()
19111 
    if self.limit is not None:
19112 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19113 
      oprot.writeI64(self.limit)
19114 
      oprot.writeFieldEnd()
19115 
    oprot.writeFieldStop()
19116 
    oprot.writeStructEnd()
19117 
 
19118 
  def validate(self):
19119 
    return
19120 
 
19121 
 
19122 
  def __repr__(self):
19123 
    L = ['%s=%r' % (key, value)
19124 
      for key, value in self.__dict__.iteritems()]
19125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19126 
 
19127 
  def __eq__(self, other):
19128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19129 
 
19130 
  def __ne__(self, other):
19131 
    return not (self == other)
19132 
 
19133 
class searchAmazonItems_result:
19134 
  """
19135 
  Attributes:
19136 
   - success
19137 
  """
19138 
 
19139 
  thrift_spec = (
19140 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19141 
  )
19142 
 
19143 
  def __init__(self, success=None,):
19144 
    self.success = success
19145 
 
19146 
  def read(self, iprot):
19147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19149 
      return
19150 
    iprot.readStructBegin()
19151 
    while True:
19152 
      (fname, ftype, fid) = iprot.readFieldBegin()
19153 
      if ftype == TType.STOP:
19154 
        break
19155 
      if fid == 0:
19156 
        if ftype == TType.LIST:
19157 
          self.success = []
19158 
          (_etype412, _size409) = iprot.readListBegin()
19159 
          for _i413 in xrange(_size409):
19160 
            _elem414 = Amazonlisted()
19161 
            _elem414.read(iprot)
19162 
            self.success.append(_elem414)
19163 
          iprot.readListEnd()
19164 
        else:
19165 
          iprot.skip(ftype)
19166 
      else:
19167 
        iprot.skip(ftype)
19168 
      iprot.readFieldEnd()
19169 
    iprot.readStructEnd()
19170 
 
19171 
  def write(self, oprot):
19172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19174 
      return
19175 
    oprot.writeStructBegin('searchAmazonItems_result')
19176 
    if self.success is not None:
19177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19179 
      for iter415 in self.success:
19180 
        iter415.write(oprot)
19181 
      oprot.writeListEnd()
19182 
      oprot.writeFieldEnd()
19183 
    oprot.writeFieldStop()
19184 
    oprot.writeStructEnd()
19185 
 
19186 
  def validate(self):
19187 
    return
19188 
 
19189 
 
19190 
  def __repr__(self):
19191 
    L = ['%s=%r' % (key, value)
19192 
      for key, value in self.__dict__.iteritems()]
19193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19194 
 
19195 
  def __eq__(self, other):
19196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19197 
 
19198 
  def __ne__(self, other):
19199 
    return not (self == other)
19200 
 
19201 
class getAmazonSearchResultCount_args:
19202 
  """
19203 
  Attributes:
19204 
   - searchTerm
19205 
  """
19206 
 
19207 
  thrift_spec = (
19208 
    None, # 0
19209 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19210 
  )
19211 
 
19212 
  def __init__(self, searchTerm=None,):
19213 
    self.searchTerm = searchTerm
19214 
 
19215 
  def read(self, iprot):
19216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19218 
      return
19219 
    iprot.readStructBegin()
19220 
    while True:
19221 
      (fname, ftype, fid) = iprot.readFieldBegin()
19222 
      if ftype == TType.STOP:
19223 
        break
19224 
      if fid == 1:
19225 
        if ftype == TType.LIST:
19226 
          self.searchTerm = []
19227 
          (_etype419, _size416) = iprot.readListBegin()
19228 
          for _i420 in xrange(_size416):
19229 
            _elem421 = iprot.readString();
19230 
            self.searchTerm.append(_elem421)
19231 
          iprot.readListEnd()
19232 
        else:
19233 
          iprot.skip(ftype)
19234 
      else:
19235 
        iprot.skip(ftype)
19236 
      iprot.readFieldEnd()
19237 
    iprot.readStructEnd()
19238 
 
19239 
  def write(self, oprot):
19240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19242 
      return
19243 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19244 
    if self.searchTerm is not None:
19245 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19246 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
19247 
      for iter422 in self.searchTerm:
19248 
        oprot.writeString(iter422)
19249 
      oprot.writeListEnd()
19250 
      oprot.writeFieldEnd()
19251 
    oprot.writeFieldStop()
19252 
    oprot.writeStructEnd()
19253 
 
19254 
  def validate(self):
19255 
    return
19256 
 
19257 
 
19258 
  def __repr__(self):
19259 
    L = ['%s=%r' % (key, value)
19260 
      for key, value in self.__dict__.iteritems()]
19261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19262 
 
19263 
  def __eq__(self, other):
19264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19265 
 
19266 
  def __ne__(self, other):
19267 
    return not (self == other)
19268 
 
19269 
class getAmazonSearchResultCount_result:
19270 
  """
19271 
  Attributes:
19272 
   - success
19273 
  """
19274 
 
19275 
  thrift_spec = (
19276 
    (0, TType.I64, 'success', None, None, ), # 0
19277 
  )
19278 
 
19279 
  def __init__(self, success=None,):
19280 
    self.success = success
19281 
 
19282 
  def read(self, iprot):
19283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19285 
      return
19286 
    iprot.readStructBegin()
19287 
    while True:
19288 
      (fname, ftype, fid) = iprot.readFieldBegin()
19289 
      if ftype == TType.STOP:
19290 
        break
19291 
      if fid == 0:
19292 
        if ftype == TType.I64:
19293 
          self.success = iprot.readI64();
19294 
        else:
19295 
          iprot.skip(ftype)
19296 
      else:
19297 
        iprot.skip(ftype)
19298 
      iprot.readFieldEnd()
19299 
    iprot.readStructEnd()
19300 
 
19301 
  def write(self, oprot):
19302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19304 
      return
19305 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19306 
    if self.success is not None:
19307 
      oprot.writeFieldBegin('success', TType.I64, 0)
19308 
      oprot.writeI64(self.success)
19309 
      oprot.writeFieldEnd()
19310 
    oprot.writeFieldStop()
19311 
    oprot.writeStructEnd()
19312 
 
19313 
  def validate(self):
19314 
    return
19315 
 
19316 
 
19317 
  def __repr__(self):
19318 
    L = ['%s=%r' % (key, value)
19319 
      for key, value in self.__dict__.iteritems()]
19320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19321 
 
19322 
  def __eq__(self, other):
19323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19324 
 
19325 
  def __ne__(self, other):
19326 
    return not (self == other)
19327 
 
19328 
class getCountForAmazonlistedItems_args:
19329 
 
19330 
  thrift_spec = (
19331 
  )
19332 
 
19333 
  def read(self, iprot):
19334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19336 
      return
19337 
    iprot.readStructBegin()
19338 
    while True:
19339 
      (fname, ftype, fid) = iprot.readFieldBegin()
19340 
      if ftype == TType.STOP:
19341 
        break
19342 
      else:
19343 
        iprot.skip(ftype)
19344 
      iprot.readFieldEnd()
19345 
    iprot.readStructEnd()
19346 
 
19347 
  def write(self, oprot):
19348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19350 
      return
19351 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19352 
    oprot.writeFieldStop()
19353 
    oprot.writeStructEnd()
19354 
 
19355 
  def validate(self):
19356 
    return
19357 
 
19358 
 
19359 
  def __repr__(self):
19360 
    L = ['%s=%r' % (key, value)
19361 
      for key, value in self.__dict__.iteritems()]
19362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19363 
 
19364 
  def __eq__(self, other):
19365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19366 
 
19367 
  def __ne__(self, other):
19368 
    return not (self == other)
19369 
 
19370 
class getCountForAmazonlistedItems_result:
19371 
  """
19372 
  Attributes:
19373 
   - success
19374 
  """
19375 
 
19376 
  thrift_spec = (
19377 
    (0, TType.I64, 'success', None, None, ), # 0
19378 
  )
19379 
 
19380 
  def __init__(self, success=None,):
19381 
    self.success = success
19382 
 
19383 
  def read(self, iprot):
19384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19386 
      return
19387 
    iprot.readStructBegin()
19388 
    while True:
19389 
      (fname, ftype, fid) = iprot.readFieldBegin()
19390 
      if ftype == TType.STOP:
19391 
        break
19392 
      if fid == 0:
19393 
        if ftype == TType.I64:
19394 
          self.success = iprot.readI64();
19395 
        else:
19396 
          iprot.skip(ftype)
19397 
      else:
19398 
        iprot.skip(ftype)
19399 
      iprot.readFieldEnd()
19400 
    iprot.readStructEnd()
19401 
 
19402 
  def write(self, oprot):
19403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19405 
      return
19406 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
19407 
    if self.success is not None:
19408 
      oprot.writeFieldBegin('success', TType.I64, 0)
19409 
      oprot.writeI64(self.success)
19410 
      oprot.writeFieldEnd()
19411 
    oprot.writeFieldStop()
19412 
    oprot.writeStructEnd()
19413 
 
19414 
  def validate(self):
19415 
    return
19416 
 
19417 
 
19418 
  def __repr__(self):
19419 
    L = ['%s=%r' % (key, value)
19420 
      for key, value in self.__dict__.iteritems()]
19421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19422 
 
19423 
  def __eq__(self, other):
19424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19425 
 
19426 
  def __ne__(self, other):
19427 
    return not (self == other)
19428 
 
7281 kshitij.so 19429 
class getAmazonItemDetails_args:
19430 
  """
19431 
  Attributes:
19432 
   - itemId
19433 
  """
19434 
 
19435 
  thrift_spec = (
19436 
    None, # 0
19437 
    (1, TType.I64, 'itemId', None, None, ), # 1
19438 
  )
19439 
 
19440 
  def __init__(self, itemId=None,):
19441 
    self.itemId = itemId
19442 
 
19443 
  def read(self, iprot):
19444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19446 
      return
19447 
    iprot.readStructBegin()
19448 
    while True:
19449 
      (fname, ftype, fid) = iprot.readFieldBegin()
19450 
      if ftype == TType.STOP:
19451 
        break
19452 
      if fid == 1:
19453 
        if ftype == TType.I64:
19454 
          self.itemId = iprot.readI64();
19455 
        else:
19456 
          iprot.skip(ftype)
19457 
      else:
19458 
        iprot.skip(ftype)
19459 
      iprot.readFieldEnd()
19460 
    iprot.readStructEnd()
19461 
 
19462 
  def write(self, oprot):
19463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19465 
      return
19466 
    oprot.writeStructBegin('getAmazonItemDetails_args')
19467 
    if self.itemId is not None:
19468 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19469 
      oprot.writeI64(self.itemId)
19470 
      oprot.writeFieldEnd()
19471 
    oprot.writeFieldStop()
19472 
    oprot.writeStructEnd()
19473 
 
19474 
  def validate(self):
19475 
    return
19476 
 
19477 
 
19478 
  def __repr__(self):
19479 
    L = ['%s=%r' % (key, value)
19480 
      for key, value in self.__dict__.iteritems()]
19481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19482 
 
19483 
  def __eq__(self, other):
19484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19485 
 
19486 
  def __ne__(self, other):
19487 
    return not (self == other)
19488 
 
19489 
class getAmazonItemDetails_result:
19490 
  """
19491 
  Attributes:
19492 
   - success
19493 
  """
19494 
 
19495 
  thrift_spec = (
19496 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
19497 
  )
19498 
 
19499 
  def __init__(self, success=None,):
19500 
    self.success = success
19501 
 
19502 
  def read(self, iprot):
19503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19505 
      return
19506 
    iprot.readStructBegin()
19507 
    while True:
19508 
      (fname, ftype, fid) = iprot.readFieldBegin()
19509 
      if ftype == TType.STOP:
19510 
        break
19511 
      if fid == 0:
19512 
        if ftype == TType.STRUCT:
19513 
          self.success = Amazonlisted()
19514 
          self.success.read(iprot)
19515 
        else:
19516 
          iprot.skip(ftype)
19517 
      else:
19518 
        iprot.skip(ftype)
19519 
      iprot.readFieldEnd()
19520 
    iprot.readStructEnd()
19521 
 
19522 
  def write(self, oprot):
19523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19525 
      return
19526 
    oprot.writeStructBegin('getAmazonItemDetails_result')
19527 
    if self.success is not None:
19528 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19529 
      self.success.write(oprot)
19530 
      oprot.writeFieldEnd()
19531 
    oprot.writeFieldStop()
19532 
    oprot.writeStructEnd()
19533 
 
19534 
  def validate(self):
19535 
    return
19536 
 
19537 
 
19538 
  def __repr__(self):
19539 
    L = ['%s=%r' % (key, value)
19540 
      for key, value in self.__dict__.iteritems()]
19541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19542 
 
19543 
  def __eq__(self, other):
19544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19545 
 
19546 
  def __ne__(self, other):
19547 
    return not (self == other)
19548 
 
19549 
class updateAmazonItemDetails_args:
19550 
  """
19551 
  Attributes:
8168 kshitij.so 19552 
   - amazonlisted
7281 kshitij.so 19553 
  """
19554 
 
19555 
  thrift_spec = (
19556 
    None, # 0
8168 kshitij.so 19557 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 19558 
  )
19559 
 
8168 kshitij.so 19560 
  def __init__(self, amazonlisted=None,):
19561 
    self.amazonlisted = amazonlisted
7281 kshitij.so 19562 
 
19563 
  def read(self, iprot):
19564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19566 
      return
19567 
    iprot.readStructBegin()
19568 
    while True:
19569 
      (fname, ftype, fid) = iprot.readFieldBegin()
19570 
      if ftype == TType.STOP:
19571 
        break
19572 
      if fid == 1:
8168 kshitij.so 19573 
        if ftype == TType.STRUCT:
19574 
          self.amazonlisted = Amazonlisted()
19575 
          self.amazonlisted.read(iprot)
7281 kshitij.so 19576 
        else:
19577 
          iprot.skip(ftype)
19578 
      else:
19579 
        iprot.skip(ftype)
19580 
      iprot.readFieldEnd()
19581 
    iprot.readStructEnd()
19582 
 
19583 
  def write(self, oprot):
19584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19586 
      return
19587 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 19588 
    if self.amazonlisted is not None:
19589 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19590 
      self.amazonlisted.write(oprot)
7281 kshitij.so 19591 
      oprot.writeFieldEnd()
19592 
    oprot.writeFieldStop()
19593 
    oprot.writeStructEnd()
19594 
 
19595 
  def validate(self):
19596 
    return
19597 
 
19598 
 
19599 
  def __repr__(self):
19600 
    L = ['%s=%r' % (key, value)
19601 
      for key, value in self.__dict__.iteritems()]
19602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19603 
 
19604 
  def __eq__(self, other):
19605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19606 
 
19607 
  def __ne__(self, other):
19608 
    return not (self == other)
19609 
 
19610 
class updateAmazonItemDetails_result:
19611 
 
19612 
  thrift_spec = (
19613 
  )
19614 
 
19615 
  def read(self, iprot):
19616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19618 
      return
19619 
    iprot.readStructBegin()
19620 
    while True:
19621 
      (fname, ftype, fid) = iprot.readFieldBegin()
19622 
      if ftype == TType.STOP:
19623 
        break
19624 
      else:
19625 
        iprot.skip(ftype)
19626 
      iprot.readFieldEnd()
19627 
    iprot.readStructEnd()
19628 
 
19629 
  def write(self, oprot):
19630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19632 
      return
19633 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19634 
    oprot.writeFieldStop()
19635 
    oprot.writeStructEnd()
19636 
 
19637 
  def validate(self):
19638 
    return
19639 
 
19640 
 
19641 
  def __repr__(self):
19642 
    L = ['%s=%r' % (key, value)
19643 
      for key, value in self.__dict__.iteritems()]
19644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19645 
 
19646 
  def __eq__(self, other):
19647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19648 
 
19649 
  def __ne__(self, other):
19650 
    return not (self == other)
19651 
 
19652 
class addAmazonItem_args:
19653 
  """
19654 
  Attributes:
19655 
   - amazonlisted
19656 
  """
19657 
 
19658 
  thrift_spec = (
19659 
    None, # 0
19660 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
19661 
  )
19662 
 
19663 
  def __init__(self, amazonlisted=None,):
19664 
    self.amazonlisted = amazonlisted
19665 
 
19666 
  def read(self, iprot):
19667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19669 
      return
19670 
    iprot.readStructBegin()
19671 
    while True:
19672 
      (fname, ftype, fid) = iprot.readFieldBegin()
19673 
      if ftype == TType.STOP:
19674 
        break
19675 
      if fid == 1:
19676 
        if ftype == TType.STRUCT:
19677 
          self.amazonlisted = Amazonlisted()
19678 
          self.amazonlisted.read(iprot)
19679 
        else:
19680 
          iprot.skip(ftype)
19681 
      else:
19682 
        iprot.skip(ftype)
19683 
      iprot.readFieldEnd()
19684 
    iprot.readStructEnd()
19685 
 
19686 
  def write(self, oprot):
19687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19689 
      return
19690 
    oprot.writeStructBegin('addAmazonItem_args')
19691 
    if self.amazonlisted is not None:
19692 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19693 
      self.amazonlisted.write(oprot)
19694 
      oprot.writeFieldEnd()
19695 
    oprot.writeFieldStop()
19696 
    oprot.writeStructEnd()
19697 
 
19698 
  def validate(self):
19699 
    return
19700 
 
19701 
 
19702 
  def __repr__(self):
19703 
    L = ['%s=%r' % (key, value)
19704 
      for key, value in self.__dict__.iteritems()]
19705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19706 
 
19707 
  def __eq__(self, other):
19708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19709 
 
19710 
  def __ne__(self, other):
19711 
    return not (self == other)
19712 
 
19713 
class addAmazonItem_result:
19714 
 
19715 
  thrift_spec = (
19716 
  )
19717 
 
19718 
  def read(self, iprot):
19719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19721 
      return
19722 
    iprot.readStructBegin()
19723 
    while True:
19724 
      (fname, ftype, fid) = iprot.readFieldBegin()
19725 
      if ftype == TType.STOP:
19726 
        break
19727 
      else:
19728 
        iprot.skip(ftype)
19729 
      iprot.readFieldEnd()
19730 
    iprot.readStructEnd()
19731 
 
19732 
  def write(self, oprot):
19733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19735 
      return
19736 
    oprot.writeStructBegin('addAmazonItem_result')
19737 
    oprot.writeFieldStop()
19738 
    oprot.writeStructEnd()
19739 
 
19740 
  def validate(self):
19741 
    return
19742 
 
19743 
 
19744 
  def __repr__(self):
19745 
    L = ['%s=%r' % (key, value)
19746 
      for key, value in self.__dict__.iteritems()]
19747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19748 
 
19749 
  def __eq__(self, other):
19750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19751 
 
19752 
  def __ne__(self, other):
19753 
    return not (self == other)
7291 vikram.rag 19754 
 
19755 
class getAsinItems_args:
19756 
 
19757 
  thrift_spec = (
19758 
  )
19759 
 
19760 
  def read(self, iprot):
19761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19763 
      return
19764 
    iprot.readStructBegin()
19765 
    while True:
19766 
      (fname, ftype, fid) = iprot.readFieldBegin()
19767 
      if ftype == TType.STOP:
19768 
        break
19769 
      else:
19770 
        iprot.skip(ftype)
19771 
      iprot.readFieldEnd()
19772 
    iprot.readStructEnd()
19773 
 
19774 
  def write(self, oprot):
19775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19777 
      return
19778 
    oprot.writeStructBegin('getAsinItems_args')
19779 
    oprot.writeFieldStop()
19780 
    oprot.writeStructEnd()
19781 
 
19782 
  def validate(self):
19783 
    return
19784 
 
19785 
 
19786 
  def __repr__(self):
19787 
    L = ['%s=%r' % (key, value)
19788 
      for key, value in self.__dict__.iteritems()]
19789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19790 
 
19791 
  def __eq__(self, other):
19792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19793 
 
19794 
  def __ne__(self, other):
19795 
    return not (self == other)
19796 
 
19797 
class getAsinItems_result:
19798 
  """
19799 
  Attributes:
19800 
   - success
19801 
  """
19802 
 
19803 
  thrift_spec = (
19804 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19805 
  )
19806 
 
19807 
  def __init__(self, success=None,):
19808 
    self.success = success
19809 
 
19810 
  def read(self, iprot):
19811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19813 
      return
19814 
    iprot.readStructBegin()
19815 
    while True:
19816 
      (fname, ftype, fid) = iprot.readFieldBegin()
19817 
      if ftype == TType.STOP:
19818 
        break
19819 
      if fid == 0:
19820 
        if ftype == TType.LIST:
19821 
          self.success = []
8619 kshitij.so 19822 
          (_etype426, _size423) = iprot.readListBegin()
19823 
          for _i427 in xrange(_size423):
19824 
            _elem428 = Item()
19825 
            _elem428.read(iprot)
19826 
            self.success.append(_elem428)
7291 vikram.rag 19827 
          iprot.readListEnd()
19828 
        else:
19829 
          iprot.skip(ftype)
19830 
      else:
19831 
        iprot.skip(ftype)
19832 
      iprot.readFieldEnd()
19833 
    iprot.readStructEnd()
19834 
 
19835 
  def write(self, oprot):
19836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19838 
      return
19839 
    oprot.writeStructBegin('getAsinItems_result')
19840 
    if self.success is not None:
19841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 19843 
      for iter429 in self.success:
19844 
        iter429.write(oprot)
7291 vikram.rag 19845 
      oprot.writeListEnd()
19846 
      oprot.writeFieldEnd()
19847 
    oprot.writeFieldStop()
19848 
    oprot.writeStructEnd()
19849 
 
19850 
  def validate(self):
19851 
    return
19852 
 
19853 
 
19854 
  def __repr__(self):
19855 
    L = ['%s=%r' % (key, value)
19856 
      for key, value in self.__dict__.iteritems()]
19857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19858 
 
19859 
  def __eq__(self, other):
19860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19861 
 
19862 
  def __ne__(self, other):
19863 
    return not (self == other)
19864 
 
19865 
class getAllFbaListedItems_args:
19866 
 
19867 
  thrift_spec = (
19868 
  )
19869 
 
19870 
  def read(self, iprot):
19871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19873 
      return
19874 
    iprot.readStructBegin()
19875 
    while True:
19876 
      (fname, ftype, fid) = iprot.readFieldBegin()
19877 
      if ftype == TType.STOP:
19878 
        break
19879 
      else:
19880 
        iprot.skip(ftype)
19881 
      iprot.readFieldEnd()
19882 
    iprot.readStructEnd()
19883 
 
19884 
  def write(self, oprot):
19885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19887 
      return
19888 
    oprot.writeStructBegin('getAllFbaListedItems_args')
19889 
    oprot.writeFieldStop()
19890 
    oprot.writeStructEnd()
19891 
 
19892 
  def validate(self):
19893 
    return
19894 
 
19895 
 
19896 
  def __repr__(self):
19897 
    L = ['%s=%r' % (key, value)
19898 
      for key, value in self.__dict__.iteritems()]
19899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19900 
 
19901 
  def __eq__(self, other):
19902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19903 
 
19904 
  def __ne__(self, other):
19905 
    return not (self == other)
19906 
 
19907 
class getAllFbaListedItems_result:
19908 
  """
19909 
  Attributes:
19910 
   - success
19911 
  """
19912 
 
19913 
  thrift_spec = (
19914 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19915 
  )
19916 
 
19917 
  def __init__(self, success=None,):
19918 
    self.success = success
19919 
 
19920 
  def read(self, iprot):
19921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19923 
      return
19924 
    iprot.readStructBegin()
19925 
    while True:
19926 
      (fname, ftype, fid) = iprot.readFieldBegin()
19927 
      if ftype == TType.STOP:
19928 
        break
19929 
      if fid == 0:
19930 
        if ftype == TType.LIST:
19931 
          self.success = []
8619 kshitij.so 19932 
          (_etype433, _size430) = iprot.readListBegin()
19933 
          for _i434 in xrange(_size430):
19934 
            _elem435 = Amazonlisted()
19935 
            _elem435.read(iprot)
19936 
            self.success.append(_elem435)
7291 vikram.rag 19937 
          iprot.readListEnd()
19938 
        else:
19939 
          iprot.skip(ftype)
19940 
      else:
19941 
        iprot.skip(ftype)
19942 
      iprot.readFieldEnd()
19943 
    iprot.readStructEnd()
19944 
 
19945 
  def write(self, oprot):
19946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19948 
      return
19949 
    oprot.writeStructBegin('getAllFbaListedItems_result')
19950 
    if self.success is not None:
19951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 19953 
      for iter436 in self.success:
19954 
        iter436.write(oprot)
7291 vikram.rag 19955 
      oprot.writeListEnd()
19956 
      oprot.writeFieldEnd()
19957 
    oprot.writeFieldStop()
19958 
    oprot.writeStructEnd()
19959 
 
19960 
  def validate(self):
19961 
    return
19962 
 
19963 
 
19964 
  def __repr__(self):
19965 
    L = ['%s=%r' % (key, value)
19966 
      for key, value in self.__dict__.iteritems()]
19967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19968 
 
19969 
  def __eq__(self, other):
19970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19971 
 
19972 
  def __ne__(self, other):
19973 
    return not (self == other)
19974 
 
19975 
class getAllNonFbaListedItems_args:
19976 
 
19977 
  thrift_spec = (
19978 
  )
19979 
 
19980 
  def read(self, iprot):
19981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19983 
      return
19984 
    iprot.readStructBegin()
19985 
    while True:
19986 
      (fname, ftype, fid) = iprot.readFieldBegin()
19987 
      if ftype == TType.STOP:
19988 
        break
19989 
      else:
19990 
        iprot.skip(ftype)
19991 
      iprot.readFieldEnd()
19992 
    iprot.readStructEnd()
19993 
 
19994 
  def write(self, oprot):
19995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19997 
      return
19998 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
19999 
    oprot.writeFieldStop()
20000 
    oprot.writeStructEnd()
20001 
 
20002 
  def validate(self):
20003 
    return
20004 
 
20005 
 
20006 
  def __repr__(self):
20007 
    L = ['%s=%r' % (key, value)
20008 
      for key, value in self.__dict__.iteritems()]
20009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20010 
 
20011 
  def __eq__(self, other):
20012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20013 
 
20014 
  def __ne__(self, other):
20015 
    return not (self == other)
20016 
 
20017 
class getAllNonFbaListedItems_result:
20018 
  """
20019 
  Attributes:
20020 
   - success
20021 
  """
20022 
 
20023 
  thrift_spec = (
20024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20025 
  )
20026 
 
20027 
  def __init__(self, success=None,):
20028 
    self.success = success
20029 
 
20030 
  def read(self, iprot):
20031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20033 
      return
20034 
    iprot.readStructBegin()
20035 
    while True:
20036 
      (fname, ftype, fid) = iprot.readFieldBegin()
20037 
      if ftype == TType.STOP:
20038 
        break
20039 
      if fid == 0:
20040 
        if ftype == TType.LIST:
20041 
          self.success = []
8619 kshitij.so 20042 
          (_etype440, _size437) = iprot.readListBegin()
20043 
          for _i441 in xrange(_size437):
20044 
            _elem442 = Amazonlisted()
20045 
            _elem442.read(iprot)
20046 
            self.success.append(_elem442)
7291 vikram.rag 20047 
          iprot.readListEnd()
20048 
        else:
20049 
          iprot.skip(ftype)
20050 
      else:
20051 
        iprot.skip(ftype)
20052 
      iprot.readFieldEnd()
20053 
    iprot.readStructEnd()
20054 
 
20055 
  def write(self, oprot):
20056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20058 
      return
20059 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20060 
    if self.success is not None:
20061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 20063 
      for iter443 in self.success:
20064 
        iter443.write(oprot)
7291 vikram.rag 20065 
      oprot.writeListEnd()
20066 
      oprot.writeFieldEnd()
20067 
    oprot.writeFieldStop()
20068 
    oprot.writeStructEnd()
20069 
 
20070 
  def validate(self):
20071 
    return
20072 
 
20073 
 
20074 
  def __repr__(self):
20075 
    L = ['%s=%r' % (key, value)
20076 
      for key, value in self.__dict__.iteritems()]
20077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20078 
 
20079 
  def __eq__(self, other):
20080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20081 
 
20082 
  def __ne__(self, other):
20083 
    return not (self == other)
7460 kshitij.so 20084 
 
20085 
class updateItemInventory_args:
20086 
  """
20087 
  Attributes:
20088 
   - itemId
20089 
   - holdInventory
20090 
   - defaultInventory
20091 
  """
20092 
 
20093 
  thrift_spec = (
20094 
    None, # 0
20095 
    (1, TType.I64, 'itemId', None, None, ), # 1
20096 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20097 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20098 
  )
20099 
 
20100 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20101 
    self.itemId = itemId
20102 
    self.holdInventory = holdInventory
20103 
    self.defaultInventory = defaultInventory
20104 
 
20105 
  def read(self, iprot):
20106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20108 
      return
20109 
    iprot.readStructBegin()
20110 
    while True:
20111 
      (fname, ftype, fid) = iprot.readFieldBegin()
20112 
      if ftype == TType.STOP:
20113 
        break
20114 
      if fid == 1:
20115 
        if ftype == TType.I64:
20116 
          self.itemId = iprot.readI64();
20117 
        else:
20118 
          iprot.skip(ftype)
20119 
      elif fid == 2:
20120 
        if ftype == TType.I64:
20121 
          self.holdInventory = iprot.readI64();
20122 
        else:
20123 
          iprot.skip(ftype)
20124 
      elif fid == 3:
20125 
        if ftype == TType.I64:
20126 
          self.defaultInventory = iprot.readI64();
20127 
        else:
20128 
          iprot.skip(ftype)
20129 
      else:
20130 
        iprot.skip(ftype)
20131 
      iprot.readFieldEnd()
20132 
    iprot.readStructEnd()
20133 
 
20134 
  def write(self, oprot):
20135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20137 
      return
20138 
    oprot.writeStructBegin('updateItemInventory_args')
20139 
    if self.itemId is not None:
20140 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20141 
      oprot.writeI64(self.itemId)
20142 
      oprot.writeFieldEnd()
20143 
    if self.holdInventory is not None:
20144 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20145 
      oprot.writeI64(self.holdInventory)
20146 
      oprot.writeFieldEnd()
20147 
    if self.defaultInventory is not None:
20148 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20149 
      oprot.writeI64(self.defaultInventory)
20150 
      oprot.writeFieldEnd()
20151 
    oprot.writeFieldStop()
20152 
    oprot.writeStructEnd()
20153 
 
20154 
  def validate(self):
20155 
    return
20156 
 
20157 
 
20158 
  def __repr__(self):
20159 
    L = ['%s=%r' % (key, value)
20160 
      for key, value in self.__dict__.iteritems()]
20161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20162 
 
20163 
  def __eq__(self, other):
20164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20165 
 
20166 
  def __ne__(self, other):
20167 
    return not (self == other)
20168 
 
20169 
class updateItemInventory_result:
20170 
  """
20171 
  Attributes:
20172 
   - success
20173 
  """
20174 
 
20175 
  thrift_spec = (
20176 
    (0, TType.BOOL, 'success', None, None, ), # 0
20177 
  )
20178 
 
20179 
  def __init__(self, success=None,):
20180 
    self.success = success
20181 
 
20182 
  def read(self, iprot):
20183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20185 
      return
20186 
    iprot.readStructBegin()
20187 
    while True:
20188 
      (fname, ftype, fid) = iprot.readFieldBegin()
20189 
      if ftype == TType.STOP:
20190 
        break
20191 
      if fid == 0:
20192 
        if ftype == TType.BOOL:
20193 
          self.success = iprot.readBool();
20194 
        else:
20195 
          iprot.skip(ftype)
20196 
      else:
20197 
        iprot.skip(ftype)
20198 
      iprot.readFieldEnd()
20199 
    iprot.readStructEnd()
20200 
 
20201 
  def write(self, oprot):
20202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20204 
      return
20205 
    oprot.writeStructBegin('updateItemInventory_result')
20206 
    if self.success is not None:
20207 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20208 
      oprot.writeBool(self.success)
20209 
      oprot.writeFieldEnd()
20210 
    oprot.writeFieldStop()
20211 
    oprot.writeStructEnd()
20212 
 
20213 
  def validate(self):
20214 
    return
20215 
 
20216 
 
20217 
  def __repr__(self):
20218 
    L = ['%s=%r' % (key, value)
20219 
      for key, value in self.__dict__.iteritems()]
20220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20221 
 
20222 
  def __eq__(self, other):
20223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20224 
 
20225 
  def __ne__(self, other):
20226 
    return not (self == other)
7770 kshitij.so 20227 
 
20228 
class updateTimestampForAmazonFeeds_args:
20229 
  """
20230 
  Attributes:
20231 
   - type
20232 
   - sku
20233 
   - timestamp
20234 
  """
20235 
 
20236 
  thrift_spec = (
20237 
    None, # 0
20238 
    (1, TType.STRING, 'type', None, None, ), # 1
20239 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20240 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20241 
  )
20242 
 
20243 
  def __init__(self, type=None, sku=None, timestamp=None,):
20244 
    self.type = type
20245 
    self.sku = sku
20246 
    self.timestamp = timestamp
20247 
 
20248 
  def read(self, iprot):
20249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20251 
      return
20252 
    iprot.readStructBegin()
20253 
    while True:
20254 
      (fname, ftype, fid) = iprot.readFieldBegin()
20255 
      if ftype == TType.STOP:
20256 
        break
20257 
      if fid == 1:
20258 
        if ftype == TType.STRING:
20259 
          self.type = iprot.readString();
20260 
        else:
20261 
          iprot.skip(ftype)
20262 
      elif fid == 2:
20263 
        if ftype == TType.LIST:
20264 
          self.sku = []
8619 kshitij.so 20265 
          (_etype447, _size444) = iprot.readListBegin()
20266 
          for _i448 in xrange(_size444):
20267 
            _elem449 = iprot.readI64();
20268 
            self.sku.append(_elem449)
7770 kshitij.so 20269 
          iprot.readListEnd()
20270 
        else:
20271 
          iprot.skip(ftype)
20272 
      elif fid == 3:
20273 
        if ftype == TType.I64:
20274 
          self.timestamp = iprot.readI64();
20275 
        else:
20276 
          iprot.skip(ftype)
20277 
      else:
20278 
        iprot.skip(ftype)
20279 
      iprot.readFieldEnd()
20280 
    iprot.readStructEnd()
20281 
 
20282 
  def write(self, oprot):
20283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20285 
      return
20286 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20287 
    if self.type is not None:
20288 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20289 
      oprot.writeString(self.type)
20290 
      oprot.writeFieldEnd()
20291 
    if self.sku is not None:
20292 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20293 
      oprot.writeListBegin(TType.I64, len(self.sku))
8619 kshitij.so 20294 
      for iter450 in self.sku:
20295 
        oprot.writeI64(iter450)
7770 kshitij.so 20296 
      oprot.writeListEnd()
20297 
      oprot.writeFieldEnd()
20298 
    if self.timestamp is not None:
20299 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20300 
      oprot.writeI64(self.timestamp)
20301 
      oprot.writeFieldEnd()
20302 
    oprot.writeFieldStop()
20303 
    oprot.writeStructEnd()
20304 
 
20305 
  def validate(self):
20306 
    return
20307 
 
20308 
 
20309 
  def __repr__(self):
20310 
    L = ['%s=%r' % (key, value)
20311 
      for key, value in self.__dict__.iteritems()]
20312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20313 
 
20314 
  def __eq__(self, other):
20315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20316 
 
20317 
  def __ne__(self, other):
20318 
    return not (self == other)
20319 
 
20320 
class updateTimestampForAmazonFeeds_result:
20321 
  """
20322 
  Attributes:
20323 
   - success
20324 
  """
20325 
 
20326 
  thrift_spec = (
20327 
    (0, TType.BOOL, 'success', None, None, ), # 0
20328 
  )
20329 
 
20330 
  def __init__(self, success=None,):
20331 
    self.success = success
20332 
 
20333 
  def read(self, iprot):
20334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20336 
      return
20337 
    iprot.readStructBegin()
20338 
    while True:
20339 
      (fname, ftype, fid) = iprot.readFieldBegin()
20340 
      if ftype == TType.STOP:
20341 
        break
20342 
      if fid == 0:
20343 
        if ftype == TType.BOOL:
20344 
          self.success = iprot.readBool();
20345 
        else:
20346 
          iprot.skip(ftype)
20347 
      else:
20348 
        iprot.skip(ftype)
20349 
      iprot.readFieldEnd()
20350 
    iprot.readStructEnd()
20351 
 
20352 
  def write(self, oprot):
20353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20355 
      return
20356 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20357 
    if self.success is not None:
20358 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20359 
      oprot.writeBool(self.success)
20360 
      oprot.writeFieldEnd()
20361 
    oprot.writeFieldStop()
20362 
    oprot.writeStructEnd()
20363 
 
20364 
  def validate(self):
20365 
    return
20366 
 
20367 
 
20368 
  def __repr__(self):
20369 
    L = ['%s=%r' % (key, value)
20370 
      for key, value in self.__dict__.iteritems()]
20371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20372 
 
20373 
  def __eq__(self, other):
20374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20375 
 
20376 
  def __ne__(self, other):
20377 
    return not (self == other)
7897 amar.kumar 20378 
 
20379 
class getAllParentCategories_args:
20380 
 
20381 
  thrift_spec = (
20382 
  )
20383 
 
20384 
  def read(self, iprot):
20385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20387 
      return
20388 
    iprot.readStructBegin()
20389 
    while True:
20390 
      (fname, ftype, fid) = iprot.readFieldBegin()
20391 
      if ftype == TType.STOP:
20392 
        break
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('getAllParentCategories_args')
20403 
    oprot.writeFieldStop()
20404 
    oprot.writeStructEnd()
20405 
 
20406 
  def validate(self):
20407 
    return
20408 
 
20409 
 
20410 
  def __repr__(self):
20411 
    L = ['%s=%r' % (key, value)
20412 
      for key, value in self.__dict__.iteritems()]
20413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20414 
 
20415 
  def __eq__(self, other):
20416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20417 
 
20418 
  def __ne__(self, other):
20419 
    return not (self == other)
20420 
 
20421 
class getAllParentCategories_result:
20422 
  """
20423 
  Attributes:
20424 
   - success
20425 
  """
20426 
 
20427 
  thrift_spec = (
20428 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
20429 
  )
20430 
 
20431 
  def __init__(self, success=None,):
20432 
    self.success = success
20433 
 
20434 
  def read(self, iprot):
20435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20437 
      return
20438 
    iprot.readStructBegin()
20439 
    while True:
20440 
      (fname, ftype, fid) = iprot.readFieldBegin()
20441 
      if ftype == TType.STOP:
20442 
        break
20443 
      if fid == 0:
20444 
        if ftype == TType.LIST:
20445 
          self.success = []
8619 kshitij.so 20446 
          (_etype454, _size451) = iprot.readListBegin()
20447 
          for _i455 in xrange(_size451):
20448 
            _elem456 = Category()
20449 
            _elem456.read(iprot)
20450 
            self.success.append(_elem456)
7897 amar.kumar 20451 
          iprot.readListEnd()
20452 
        else:
20453 
          iprot.skip(ftype)
20454 
      else:
20455 
        iprot.skip(ftype)
20456 
      iprot.readFieldEnd()
20457 
    iprot.readStructEnd()
20458 
 
20459 
  def write(self, oprot):
20460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20462 
      return
20463 
    oprot.writeStructBegin('getAllParentCategories_result')
20464 
    if self.success is not None:
20465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 20467 
      for iter457 in self.success:
20468 
        iter457.write(oprot)
7897 amar.kumar 20469 
      oprot.writeListEnd()
20470 
      oprot.writeFieldEnd()
20471 
    oprot.writeFieldStop()
20472 
    oprot.writeStructEnd()
20473 
 
20474 
  def validate(self):
20475 
    return
20476 
 
20477 
 
20478 
  def __repr__(self):
20479 
    L = ['%s=%r' % (key, value)
20480 
      for key, value in self.__dict__.iteritems()]
20481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20482 
 
20483 
  def __eq__(self, other):
20484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20485 
 
20486 
  def __ne__(self, other):
20487 
    return not (self == other)
7977 kshitij.so 20488 
 
20489 
class addPageViewEvent_args:
20490 
  """
20491 
  Attributes:
20492 
   - pageViewEvents
20493 
  """
20494 
 
20495 
  thrift_spec = (
20496 
    None, # 0
20497 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
20498 
  )
20499 
 
20500 
  def __init__(self, pageViewEvents=None,):
20501 
    self.pageViewEvents = pageViewEvents
20502 
 
20503 
  def read(self, iprot):
20504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20506 
      return
20507 
    iprot.readStructBegin()
20508 
    while True:
20509 
      (fname, ftype, fid) = iprot.readFieldBegin()
20510 
      if ftype == TType.STOP:
20511 
        break
20512 
      if fid == 1:
20513 
        if ftype == TType.STRUCT:
20514 
          self.pageViewEvents = PageViewEvents()
20515 
          self.pageViewEvents.read(iprot)
20516 
        else:
20517 
          iprot.skip(ftype)
20518 
      else:
20519 
        iprot.skip(ftype)
20520 
      iprot.readFieldEnd()
20521 
    iprot.readStructEnd()
20522 
 
20523 
  def write(self, oprot):
20524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20526 
      return
20527 
    oprot.writeStructBegin('addPageViewEvent_args')
20528 
    if self.pageViewEvents is not None:
20529 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
20530 
      self.pageViewEvents.write(oprot)
20531 
      oprot.writeFieldEnd()
20532 
    oprot.writeFieldStop()
20533 
    oprot.writeStructEnd()
20534 
 
20535 
  def validate(self):
20536 
    return
20537 
 
20538 
 
20539 
  def __repr__(self):
20540 
    L = ['%s=%r' % (key, value)
20541 
      for key, value in self.__dict__.iteritems()]
20542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20543 
 
20544 
  def __eq__(self, other):
20545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20546 
 
20547 
  def __ne__(self, other):
20548 
    return not (self == other)
20549 
 
20550 
class addPageViewEvent_result:
20551 
 
20552 
  thrift_spec = (
20553 
  )
20554 
 
20555 
  def read(self, iprot):
20556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20558 
      return
20559 
    iprot.readStructBegin()
20560 
    while True:
20561 
      (fname, ftype, fid) = iprot.readFieldBegin()
20562 
      if ftype == TType.STOP:
20563 
        break
20564 
      else:
20565 
        iprot.skip(ftype)
20566 
      iprot.readFieldEnd()
20567 
    iprot.readStructEnd()
20568 
 
20569 
  def write(self, oprot):
20570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20572 
      return
20573 
    oprot.writeStructBegin('addPageViewEvent_result')
20574 
    oprot.writeFieldStop()
20575 
    oprot.writeStructEnd()
20576 
 
20577 
  def validate(self):
20578 
    return
20579 
 
20580 
 
20581 
  def __repr__(self):
20582 
    L = ['%s=%r' % (key, value)
20583 
      for key, value in self.__dict__.iteritems()]
20584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20585 
 
20586 
  def __eq__(self, other):
20587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20588 
 
20589 
  def __ne__(self, other):
20590 
    return not (self == other)
20591 
 
20592 
class addCartEvent_args:
20593 
  """
20594 
  Attributes:
20595 
   - cartEvents
20596 
  """
20597 
 
20598 
  thrift_spec = (
20599 
    None, # 0
20600 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
20601 
  )
20602 
 
20603 
  def __init__(self, cartEvents=None,):
20604 
    self.cartEvents = cartEvents
20605 
 
20606 
  def read(self, iprot):
20607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20609 
      return
20610 
    iprot.readStructBegin()
20611 
    while True:
20612 
      (fname, ftype, fid) = iprot.readFieldBegin()
20613 
      if ftype == TType.STOP:
20614 
        break
20615 
      if fid == 1:
20616 
        if ftype == TType.STRUCT:
20617 
          self.cartEvents = CartEvents()
20618 
          self.cartEvents.read(iprot)
20619 
        else:
20620 
          iprot.skip(ftype)
20621 
      else:
20622 
        iprot.skip(ftype)
20623 
      iprot.readFieldEnd()
20624 
    iprot.readStructEnd()
20625 
 
20626 
  def write(self, oprot):
20627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20629 
      return
20630 
    oprot.writeStructBegin('addCartEvent_args')
20631 
    if self.cartEvents is not None:
20632 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20633 
      self.cartEvents.write(oprot)
20634 
      oprot.writeFieldEnd()
20635 
    oprot.writeFieldStop()
20636 
    oprot.writeStructEnd()
20637 
 
20638 
  def validate(self):
20639 
    return
20640 
 
20641 
 
20642 
  def __repr__(self):
20643 
    L = ['%s=%r' % (key, value)
20644 
      for key, value in self.__dict__.iteritems()]
20645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20646 
 
20647 
  def __eq__(self, other):
20648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20649 
 
20650 
  def __ne__(self, other):
20651 
    return not (self == other)
20652 
 
20653 
class addCartEvent_result:
20654 
 
20655 
  thrift_spec = (
20656 
  )
20657 
 
20658 
  def read(self, iprot):
20659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20661 
      return
20662 
    iprot.readStructBegin()
20663 
    while True:
20664 
      (fname, ftype, fid) = iprot.readFieldBegin()
20665 
      if ftype == TType.STOP:
20666 
        break
20667 
      else:
20668 
        iprot.skip(ftype)
20669 
      iprot.readFieldEnd()
20670 
    iprot.readStructEnd()
20671 
 
20672 
  def write(self, oprot):
20673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20675 
      return
20676 
    oprot.writeStructBegin('addCartEvent_result')
20677 
    oprot.writeFieldStop()
20678 
    oprot.writeStructEnd()
20679 
 
20680 
  def validate(self):
20681 
    return
20682 
 
20683 
 
20684 
  def __repr__(self):
20685 
    L = ['%s=%r' % (key, value)
20686 
      for key, value in self.__dict__.iteritems()]
20687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20688 
 
20689 
  def __eq__(self, other):
20690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20691 
 
20692 
  def __ne__(self, other):
20693 
    return not (self == other)
8139 kshitij.so 20694 
 
8182 amar.kumar 20695 
class addEbayItem_args:
20696 
  """
20697 
  Attributes:
20698 
   - ebayItem
20699 
  """
20700 
 
20701 
  thrift_spec = (
20702 
    None, # 0
20703 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20704 
  )
20705 
 
20706 
  def __init__(self, ebayItem=None,):
20707 
    self.ebayItem = ebayItem
20708 
 
20709 
  def read(self, iprot):
20710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20712 
      return
20713 
    iprot.readStructBegin()
20714 
    while True:
20715 
      (fname, ftype, fid) = iprot.readFieldBegin()
20716 
      if ftype == TType.STOP:
20717 
        break
20718 
      if fid == 1:
20719 
        if ftype == TType.STRUCT:
20720 
          self.ebayItem = EbayItem()
20721 
          self.ebayItem.read(iprot)
20722 
        else:
20723 
          iprot.skip(ftype)
20724 
      else:
20725 
        iprot.skip(ftype)
20726 
      iprot.readFieldEnd()
20727 
    iprot.readStructEnd()
20728 
 
20729 
  def write(self, oprot):
20730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20732 
      return
20733 
    oprot.writeStructBegin('addEbayItem_args')
20734 
    if self.ebayItem is not None:
20735 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20736 
      self.ebayItem.write(oprot)
20737 
      oprot.writeFieldEnd()
20738 
    oprot.writeFieldStop()
20739 
    oprot.writeStructEnd()
20740 
 
20741 
  def validate(self):
20742 
    return
20743 
 
20744 
 
20745 
  def __repr__(self):
20746 
    L = ['%s=%r' % (key, value)
20747 
      for key, value in self.__dict__.iteritems()]
20748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20749 
 
20750 
  def __eq__(self, other):
20751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20752 
 
20753 
  def __ne__(self, other):
20754 
    return not (self == other)
20755 
 
20756 
class addEbayItem_result:
20757 
 
20758 
  thrift_spec = (
20759 
  )
20760 
 
20761 
  def read(self, iprot):
20762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20764 
      return
20765 
    iprot.readStructBegin()
20766 
    while True:
20767 
      (fname, ftype, fid) = iprot.readFieldBegin()
20768 
      if ftype == TType.STOP:
20769 
        break
20770 
      else:
20771 
        iprot.skip(ftype)
20772 
      iprot.readFieldEnd()
20773 
    iprot.readStructEnd()
20774 
 
20775 
  def write(self, oprot):
20776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20778 
      return
20779 
    oprot.writeStructBegin('addEbayItem_result')
20780 
    oprot.writeFieldStop()
20781 
    oprot.writeStructEnd()
20782 
 
20783 
  def validate(self):
20784 
    return
20785 
 
20786 
 
20787 
  def __repr__(self):
20788 
    L = ['%s=%r' % (key, value)
20789 
      for key, value in self.__dict__.iteritems()]
20790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20791 
 
20792 
  def __eq__(self, other):
20793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20794 
 
20795 
  def __ne__(self, other):
20796 
    return not (self == other)
20797 
 
20798 
class getEbayItem_args:
20799 
  """
20800 
  Attributes:
20801 
   - listingId
20802 
  """
20803 
 
20804 
  thrift_spec = (
20805 
    None, # 0
20806 
    (1, TType.STRING, 'listingId', None, None, ), # 1
20807 
  )
20808 
 
20809 
  def __init__(self, listingId=None,):
20810 
    self.listingId = listingId
20811 
 
20812 
  def read(self, iprot):
20813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20815 
      return
20816 
    iprot.readStructBegin()
20817 
    while True:
20818 
      (fname, ftype, fid) = iprot.readFieldBegin()
20819 
      if ftype == TType.STOP:
20820 
        break
20821 
      if fid == 1:
20822 
        if ftype == TType.STRING:
20823 
          self.listingId = iprot.readString();
20824 
        else:
20825 
          iprot.skip(ftype)
20826 
      else:
20827 
        iprot.skip(ftype)
20828 
      iprot.readFieldEnd()
20829 
    iprot.readStructEnd()
20830 
 
20831 
  def write(self, oprot):
20832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20834 
      return
20835 
    oprot.writeStructBegin('getEbayItem_args')
20836 
    if self.listingId is not None:
20837 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
20838 
      oprot.writeString(self.listingId)
20839 
      oprot.writeFieldEnd()
20840 
    oprot.writeFieldStop()
20841 
    oprot.writeStructEnd()
20842 
 
20843 
  def validate(self):
20844 
    return
20845 
 
20846 
 
20847 
  def __repr__(self):
20848 
    L = ['%s=%r' % (key, value)
20849 
      for key, value in self.__dict__.iteritems()]
20850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20851 
 
20852 
  def __eq__(self, other):
20853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20854 
 
20855 
  def __ne__(self, other):
20856 
    return not (self == other)
20857 
 
20858 
class getEbayItem_result:
20859 
  """
20860 
  Attributes:
20861 
   - success
20862 
  """
20863 
 
20864 
  thrift_spec = (
20865 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
20866 
  )
20867 
 
20868 
  def __init__(self, success=None,):
20869 
    self.success = success
20870 
 
20871 
  def read(self, iprot):
20872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20874 
      return
20875 
    iprot.readStructBegin()
20876 
    while True:
20877 
      (fname, ftype, fid) = iprot.readFieldBegin()
20878 
      if ftype == TType.STOP:
20879 
        break
20880 
      if fid == 0:
20881 
        if ftype == TType.STRUCT:
20882 
          self.success = EbayItem()
20883 
          self.success.read(iprot)
20884 
        else:
20885 
          iprot.skip(ftype)
20886 
      else:
20887 
        iprot.skip(ftype)
20888 
      iprot.readFieldEnd()
20889 
    iprot.readStructEnd()
20890 
 
20891 
  def write(self, oprot):
20892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20894 
      return
20895 
    oprot.writeStructBegin('getEbayItem_result')
20896 
    if self.success is not None:
20897 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20898 
      self.success.write(oprot)
20899 
      oprot.writeFieldEnd()
20900 
    oprot.writeFieldStop()
20901 
    oprot.writeStructEnd()
20902 
 
20903 
  def validate(self):
20904 
    return
20905 
 
20906 
 
20907 
  def __repr__(self):
20908 
    L = ['%s=%r' % (key, value)
20909 
      for key, value in self.__dict__.iteritems()]
20910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20911 
 
20912 
  def __eq__(self, other):
20913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20914 
 
20915 
  def __ne__(self, other):
20916 
    return not (self == other)
20917 
 
20918 
class updateEbayItem_args:
20919 
  """
20920 
  Attributes:
20921 
   - ebayItem
20922 
  """
20923 
 
20924 
  thrift_spec = (
20925 
    None, # 0
20926 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20927 
  )
20928 
 
20929 
  def __init__(self, ebayItem=None,):
20930 
    self.ebayItem = ebayItem
20931 
 
20932 
  def read(self, iprot):
20933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20935 
      return
20936 
    iprot.readStructBegin()
20937 
    while True:
20938 
      (fname, ftype, fid) = iprot.readFieldBegin()
20939 
      if ftype == TType.STOP:
20940 
        break
20941 
      if fid == 1:
20942 
        if ftype == TType.STRUCT:
20943 
          self.ebayItem = EbayItem()
20944 
          self.ebayItem.read(iprot)
20945 
        else:
20946 
          iprot.skip(ftype)
20947 
      else:
20948 
        iprot.skip(ftype)
20949 
      iprot.readFieldEnd()
20950 
    iprot.readStructEnd()
20951 
 
20952 
  def write(self, oprot):
20953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20955 
      return
20956 
    oprot.writeStructBegin('updateEbayItem_args')
20957 
    if self.ebayItem is not None:
20958 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20959 
      self.ebayItem.write(oprot)
20960 
      oprot.writeFieldEnd()
20961 
    oprot.writeFieldStop()
20962 
    oprot.writeStructEnd()
20963 
 
20964 
  def validate(self):
20965 
    return
20966 
 
20967 
 
20968 
  def __repr__(self):
20969 
    L = ['%s=%r' % (key, value)
20970 
      for key, value in self.__dict__.iteritems()]
20971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20972 
 
20973 
  def __eq__(self, other):
20974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20975 
 
20976 
  def __ne__(self, other):
20977 
    return not (self == other)
20978 
 
20979 
class updateEbayItem_result:
20980 
 
20981 
  thrift_spec = (
20982 
  )
20983 
 
20984 
  def read(self, iprot):
20985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20987 
      return
20988 
    iprot.readStructBegin()
20989 
    while True:
20990 
      (fname, ftype, fid) = iprot.readFieldBegin()
20991 
      if ftype == TType.STOP:
20992 
        break
20993 
      else:
20994 
        iprot.skip(ftype)
20995 
      iprot.readFieldEnd()
20996 
    iprot.readStructEnd()
20997 
 
20998 
  def write(self, oprot):
20999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21001 
      return
21002 
    oprot.writeStructBegin('updateEbayItem_result')
21003 
    oprot.writeFieldStop()
21004 
    oprot.writeStructEnd()
21005 
 
21006 
  def validate(self):
21007 
    return
21008 
 
21009 
 
21010 
  def __repr__(self):
21011 
    L = ['%s=%r' % (key, value)
21012 
      for key, value in self.__dict__.iteritems()]
21013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21014 
 
21015 
  def __eq__(self, other):
21016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21017 
 
21018 
  def __ne__(self, other):
21019 
    return not (self == other)
21020 
 
8139 kshitij.so 21021 
class getAmazonListedItems_args:
21022 
  """
21023 
  Attributes:
21024 
   - offset
21025 
   - limit
21026 
  """
21027 
 
21028 
  thrift_spec = (
21029 
    None, # 0
21030 
    (1, TType.I64, 'offset', None, None, ), # 1
21031 
    (2, TType.I64, 'limit', None, None, ), # 2
21032 
  )
21033 
 
21034 
  def __init__(self, offset=None, limit=None,):
21035 
    self.offset = offset
21036 
    self.limit = limit
21037 
 
21038 
  def read(self, iprot):
21039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21041 
      return
21042 
    iprot.readStructBegin()
21043 
    while True:
21044 
      (fname, ftype, fid) = iprot.readFieldBegin()
21045 
      if ftype == TType.STOP:
21046 
        break
21047 
      if fid == 1:
21048 
        if ftype == TType.I64:
21049 
          self.offset = iprot.readI64();
21050 
        else:
21051 
          iprot.skip(ftype)
21052 
      elif fid == 2:
21053 
        if ftype == TType.I64:
21054 
          self.limit = iprot.readI64();
21055 
        else:
21056 
          iprot.skip(ftype)
21057 
      else:
21058 
        iprot.skip(ftype)
21059 
      iprot.readFieldEnd()
21060 
    iprot.readStructEnd()
21061 
 
21062 
  def write(self, oprot):
21063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21065 
      return
21066 
    oprot.writeStructBegin('getAmazonListedItems_args')
21067 
    if self.offset is not None:
21068 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21069 
      oprot.writeI64(self.offset)
21070 
      oprot.writeFieldEnd()
21071 
    if self.limit is not None:
21072 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21073 
      oprot.writeI64(self.limit)
21074 
      oprot.writeFieldEnd()
21075 
    oprot.writeFieldStop()
21076 
    oprot.writeStructEnd()
21077 
 
21078 
  def validate(self):
21079 
    return
21080 
 
21081 
 
21082 
  def __repr__(self):
21083 
    L = ['%s=%r' % (key, value)
21084 
      for key, value in self.__dict__.iteritems()]
21085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21086 
 
21087 
  def __eq__(self, other):
21088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21089 
 
21090 
  def __ne__(self, other):
21091 
    return not (self == other)
21092 
 
21093 
class getAmazonListedItems_result:
21094 
  """
21095 
  Attributes:
21096 
   - success
21097 
  """
21098 
 
21099 
  thrift_spec = (
21100 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21101 
  )
21102 
 
21103 
  def __init__(self, success=None,):
21104 
    self.success = success
21105 
 
21106 
  def read(self, iprot):
21107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21109 
      return
21110 
    iprot.readStructBegin()
21111 
    while True:
21112 
      (fname, ftype, fid) = iprot.readFieldBegin()
21113 
      if ftype == TType.STOP:
21114 
        break
21115 
      if fid == 0:
21116 
        if ftype == TType.LIST:
21117 
          self.success = []
8619 kshitij.so 21118 
          (_etype461, _size458) = iprot.readListBegin()
21119 
          for _i462 in xrange(_size458):
21120 
            _elem463 = Amazonlisted()
21121 
            _elem463.read(iprot)
21122 
            self.success.append(_elem463)
8139 kshitij.so 21123 
          iprot.readListEnd()
21124 
        else:
21125 
          iprot.skip(ftype)
21126 
      else:
21127 
        iprot.skip(ftype)
21128 
      iprot.readFieldEnd()
21129 
    iprot.readStructEnd()
21130 
 
21131 
  def write(self, oprot):
21132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21134 
      return
21135 
    oprot.writeStructBegin('getAmazonListedItems_result')
21136 
    if self.success is not None:
21137 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21138 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21139 
      for iter464 in self.success:
21140 
        iter464.write(oprot)
8139 kshitij.so 21141 
      oprot.writeListEnd()
21142 
      oprot.writeFieldEnd()
21143 
    oprot.writeFieldStop()
21144 
    oprot.writeStructEnd()
21145 
 
21146 
  def validate(self):
21147 
    return
21148 
 
21149 
 
21150 
  def __repr__(self):
21151 
    L = ['%s=%r' % (key, value)
21152 
      for key, value in self.__dict__.iteritems()]
21153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21154 
 
21155 
  def __eq__(self, other):
21156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21157 
 
21158 
  def __ne__(self, other):
21159 
    return not (self == other)
8168 kshitij.so 21160 
 
21161 
class updateAmazonAttributesInBulk_args:
21162 
  """
21163 
  Attributes:
21164 
   - amazonlisted
21165 
  """
21166 
 
21167 
  thrift_spec = (
21168 
    None, # 0
21169 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21170 
  )
21171 
 
21172 
  def __init__(self, amazonlisted=None,):
21173 
    self.amazonlisted = amazonlisted
21174 
 
21175 
  def read(self, iprot):
21176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21178 
      return
21179 
    iprot.readStructBegin()
21180 
    while True:
21181 
      (fname, ftype, fid) = iprot.readFieldBegin()
21182 
      if ftype == TType.STOP:
21183 
        break
21184 
      if fid == 1:
21185 
        if ftype == TType.MAP:
21186 
          self.amazonlisted = {}
8619 kshitij.so 21187 
          (_ktype466, _vtype467, _size465 ) = iprot.readMapBegin()
21188 
          for _i469 in xrange(_size465):
21189 
            _key470 = iprot.readI64();
21190 
            _val471 = Amazonlisted()
21191 
            _val471.read(iprot)
21192 
            self.amazonlisted[_key470] = _val471
8168 kshitij.so 21193 
          iprot.readMapEnd()
21194 
        else:
21195 
          iprot.skip(ftype)
21196 
      else:
21197 
        iprot.skip(ftype)
21198 
      iprot.readFieldEnd()
21199 
    iprot.readStructEnd()
21200 
 
21201 
  def write(self, oprot):
21202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21204 
      return
21205 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
21206 
    if self.amazonlisted is not None:
21207 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21208 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
8619 kshitij.so 21209 
      for kiter472,viter473 in self.amazonlisted.items():
21210 
        oprot.writeI64(kiter472)
21211 
        viter473.write(oprot)
8168 kshitij.so 21212 
      oprot.writeMapEnd()
21213 
      oprot.writeFieldEnd()
21214 
    oprot.writeFieldStop()
21215 
    oprot.writeStructEnd()
21216 
 
21217 
  def validate(self):
21218 
    return
21219 
 
21220 
 
21221 
  def __repr__(self):
21222 
    L = ['%s=%r' % (key, value)
21223 
      for key, value in self.__dict__.iteritems()]
21224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21225 
 
21226 
  def __eq__(self, other):
21227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21228 
 
21229 
  def __ne__(self, other):
21230 
    return not (self == other)
21231 
 
21232 
class updateAmazonAttributesInBulk_result:
21233 
  """
21234 
  Attributes:
21235 
   - success
21236 
  """
21237 
 
21238 
  thrift_spec = (
21239 
    (0, TType.BOOL, 'success', None, None, ), # 0
21240 
  )
21241 
 
21242 
  def __init__(self, success=None,):
21243 
    self.success = success
21244 
 
21245 
  def read(self, iprot):
21246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21248 
      return
21249 
    iprot.readStructBegin()
21250 
    while True:
21251 
      (fname, ftype, fid) = iprot.readFieldBegin()
21252 
      if ftype == TType.STOP:
21253 
        break
21254 
      if fid == 0:
21255 
        if ftype == TType.BOOL:
21256 
          self.success = iprot.readBool();
21257 
        else:
21258 
          iprot.skip(ftype)
21259 
      else:
21260 
        iprot.skip(ftype)
21261 
      iprot.readFieldEnd()
21262 
    iprot.readStructEnd()
21263 
 
21264 
  def write(self, oprot):
21265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21267 
      return
21268 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21269 
    if self.success is not None:
21270 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21271 
      oprot.writeBool(self.success)
21272 
      oprot.writeFieldEnd()
21273 
    oprot.writeFieldStop()
21274 
    oprot.writeStructEnd()
21275 
 
21276 
  def validate(self):
21277 
    return
21278 
 
21279 
 
21280 
  def __repr__(self):
21281 
    L = ['%s=%r' % (key, value)
21282 
      for key, value in self.__dict__.iteritems()]
21283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21284 
 
21285 
  def __eq__(self, other):
21286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21287 
 
21288 
  def __ne__(self, other):
21289 
    return not (self == other)
8379 vikram.rag 21290 
 
21291 
class getAllItemstoListOnFba_args:
21292 
 
21293 
  thrift_spec = (
21294 
  )
21295 
 
21296 
  def read(self, iprot):
21297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21299 
      return
21300 
    iprot.readStructBegin()
21301 
    while True:
21302 
      (fname, ftype, fid) = iprot.readFieldBegin()
21303 
      if ftype == TType.STOP:
21304 
        break
21305 
      else:
21306 
        iprot.skip(ftype)
21307 
      iprot.readFieldEnd()
21308 
    iprot.readStructEnd()
21309 
 
21310 
  def write(self, oprot):
21311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21313 
      return
21314 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21315 
    oprot.writeFieldStop()
21316 
    oprot.writeStructEnd()
21317 
 
21318 
  def validate(self):
21319 
    return
21320 
 
21321 
 
21322 
  def __repr__(self):
21323 
    L = ['%s=%r' % (key, value)
21324 
      for key, value in self.__dict__.iteritems()]
21325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21326 
 
21327 
  def __eq__(self, other):
21328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21329 
 
21330 
  def __ne__(self, other):
21331 
    return not (self == other)
21332 
 
21333 
class getAllItemstoListOnFba_result:
21334 
  """
21335 
  Attributes:
21336 
   - success
21337 
  """
21338 
 
21339 
  thrift_spec = (
21340 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21341 
  )
21342 
 
21343 
  def __init__(self, success=None,):
21344 
    self.success = success
21345 
 
21346 
  def read(self, iprot):
21347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21349 
      return
21350 
    iprot.readStructBegin()
21351 
    while True:
21352 
      (fname, ftype, fid) = iprot.readFieldBegin()
21353 
      if ftype == TType.STOP:
21354 
        break
21355 
      if fid == 0:
21356 
        if ftype == TType.LIST:
21357 
          self.success = []
8619 kshitij.so 21358 
          (_etype477, _size474) = iprot.readListBegin()
21359 
          for _i478 in xrange(_size474):
21360 
            _elem479 = Amazonlisted()
21361 
            _elem479.read(iprot)
21362 
            self.success.append(_elem479)
8379 vikram.rag 21363 
          iprot.readListEnd()
21364 
        else:
21365 
          iprot.skip(ftype)
21366 
      else:
21367 
        iprot.skip(ftype)
21368 
      iprot.readFieldEnd()
21369 
    iprot.readStructEnd()
21370 
 
21371 
  def write(self, oprot):
21372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21374 
      return
21375 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
21376 
    if self.success is not None:
21377 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21378 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21379 
      for iter480 in self.success:
21380 
        iter480.write(oprot)
8379 vikram.rag 21381 
      oprot.writeListEnd()
21382 
      oprot.writeFieldEnd()
21383 
    oprot.writeFieldStop()
21384 
    oprot.writeStructEnd()
21385 
 
21386 
  def validate(self):
21387 
    return
21388 
 
21389 
 
21390 
  def __repr__(self):
21391 
    L = ['%s=%r' % (key, value)
21392 
      for key, value in self.__dict__.iteritems()]
21393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21394 
 
21395 
  def __eq__(self, other):
21396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21397 
 
21398 
  def __ne__(self, other):
21399 
    return not (self == other)
21400 
 
21401 
class getAllItemstoListOnNonFba_args:
21402 
 
21403 
  thrift_spec = (
21404 
  )
21405 
 
21406 
  def read(self, iprot):
21407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21409 
      return
21410 
    iprot.readStructBegin()
21411 
    while True:
21412 
      (fname, ftype, fid) = iprot.readFieldBegin()
21413 
      if ftype == TType.STOP:
21414 
        break
21415 
      else:
21416 
        iprot.skip(ftype)
21417 
      iprot.readFieldEnd()
21418 
    iprot.readStructEnd()
21419 
 
21420 
  def write(self, oprot):
21421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21423 
      return
21424 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
21425 
    oprot.writeFieldStop()
21426 
    oprot.writeStructEnd()
21427 
 
21428 
  def validate(self):
21429 
    return
21430 
 
21431 
 
21432 
  def __repr__(self):
21433 
    L = ['%s=%r' % (key, value)
21434 
      for key, value in self.__dict__.iteritems()]
21435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21436 
 
21437 
  def __eq__(self, other):
21438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21439 
 
21440 
  def __ne__(self, other):
21441 
    return not (self == other)
21442 
 
21443 
class getAllItemstoListOnNonFba_result:
21444 
  """
21445 
  Attributes:
21446 
   - success
21447 
  """
21448 
 
21449 
  thrift_spec = (
21450 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21451 
  )
21452 
 
21453 
  def __init__(self, success=None,):
21454 
    self.success = success
21455 
 
21456 
  def read(self, iprot):
21457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21459 
      return
21460 
    iprot.readStructBegin()
21461 
    while True:
21462 
      (fname, ftype, fid) = iprot.readFieldBegin()
21463 
      if ftype == TType.STOP:
21464 
        break
21465 
      if fid == 0:
21466 
        if ftype == TType.LIST:
21467 
          self.success = []
8619 kshitij.so 21468 
          (_etype484, _size481) = iprot.readListBegin()
21469 
          for _i485 in xrange(_size481):
21470 
            _elem486 = Amazonlisted()
21471 
            _elem486.read(iprot)
21472 
            self.success.append(_elem486)
8379 vikram.rag 21473 
          iprot.readListEnd()
21474 
        else:
21475 
          iprot.skip(ftype)
21476 
      else:
21477 
        iprot.skip(ftype)
21478 
      iprot.readFieldEnd()
21479 
    iprot.readStructEnd()
21480 
 
21481 
  def write(self, oprot):
21482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21484 
      return
21485 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
21486 
    if self.success is not None:
21487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21489 
      for iter487 in self.success:
21490 
        iter487.write(oprot)
8379 vikram.rag 21491 
      oprot.writeListEnd()
21492 
      oprot.writeFieldEnd()
21493 
    oprot.writeFieldStop()
21494 
    oprot.writeStructEnd()
21495 
 
21496 
  def validate(self):
21497 
    return
21498 
 
21499 
 
21500 
  def __repr__(self):
21501 
    L = ['%s=%r' % (key, value)
21502 
      for key, value in self.__dict__.iteritems()]
21503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21504 
 
21505 
  def __eq__(self, other):
21506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21507 
 
21508 
  def __ne__(self, other):
21509 
    return not (self == other)
8616 vikram.rag 21510 
 
21511 
class getAllSnapdealListedActiveItems_args:
21512 
 
21513 
  thrift_spec = (
21514 
  )
21515 
 
21516 
  def read(self, iprot):
21517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21519 
      return
21520 
    iprot.readStructBegin()
21521 
    while True:
21522 
      (fname, ftype, fid) = iprot.readFieldBegin()
21523 
      if ftype == TType.STOP:
21524 
        break
21525 
      else:
21526 
        iprot.skip(ftype)
21527 
      iprot.readFieldEnd()
21528 
    iprot.readStructEnd()
21529 
 
21530 
  def write(self, oprot):
21531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21533 
      return
21534 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_args')
21535 
    oprot.writeFieldStop()
21536 
    oprot.writeStructEnd()
21537 
 
21538 
  def validate(self):
21539 
    return
21540 
 
21541 
 
21542 
  def __repr__(self):
21543 
    L = ['%s=%r' % (key, value)
21544 
      for key, value in self.__dict__.iteritems()]
21545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21546 
 
21547 
  def __eq__(self, other):
21548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21549 
 
21550 
  def __ne__(self, other):
21551 
    return not (self == other)
21552 
 
21553 
class getAllSnapdealListedActiveItems_result:
21554 
  """
21555 
  Attributes:
21556 
   - success
21557 
  """
21558 
 
21559 
  thrift_spec = (
21560 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21561 
  )
21562 
 
21563 
  def __init__(self, success=None,):
21564 
    self.success = success
21565 
 
21566 
  def read(self, iprot):
21567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21569 
      return
21570 
    iprot.readStructBegin()
21571 
    while True:
21572 
      (fname, ftype, fid) = iprot.readFieldBegin()
21573 
      if ftype == TType.STOP:
21574 
        break
21575 
      if fid == 0:
21576 
        if ftype == TType.LIST:
21577 
          self.success = []
8619 kshitij.so 21578 
          (_etype491, _size488) = iprot.readListBegin()
21579 
          for _i492 in xrange(_size488):
21580 
            _elem493 = Item()
21581 
            _elem493.read(iprot)
21582 
            self.success.append(_elem493)
8616 vikram.rag 21583 
          iprot.readListEnd()
21584 
        else:
21585 
          iprot.skip(ftype)
21586 
      else:
21587 
        iprot.skip(ftype)
21588 
      iprot.readFieldEnd()
21589 
    iprot.readStructEnd()
21590 
 
21591 
  def write(self, oprot):
21592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21594 
      return
21595 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_result')
21596 
    if self.success is not None:
21597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21598 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21599 
      for iter494 in self.success:
21600 
        iter494.write(oprot)
8616 vikram.rag 21601 
      oprot.writeListEnd()
21602 
      oprot.writeFieldEnd()
21603 
    oprot.writeFieldStop()
21604 
    oprot.writeStructEnd()
21605 
 
21606 
  def validate(self):
21607 
    return
21608 
 
21609 
 
21610 
  def __repr__(self):
21611 
    L = ['%s=%r' % (key, value)
21612 
      for key, value in self.__dict__.iteritems()]
21613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21614 
 
21615 
  def __eq__(self, other):
21616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21617 
 
21618 
  def __ne__(self, other):
21619 
    return not (self == other)
8619 kshitij.so 21620 
 
21621 
class updateAsin_args:
21622 
  """
21623 
  Attributes:
21624 
   - item
21625 
  """
21626 
 
21627 
  thrift_spec = (
21628 
    None, # 0
21629 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
21630 
  )
21631 
 
21632 
  def __init__(self, item=None,):
21633 
    self.item = item
21634 
 
21635 
  def read(self, iprot):
21636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21638 
      return
21639 
    iprot.readStructBegin()
21640 
    while True:
21641 
      (fname, ftype, fid) = iprot.readFieldBegin()
21642 
      if ftype == TType.STOP:
21643 
        break
21644 
      if fid == 1:
21645 
        if ftype == TType.MAP:
21646 
          self.item = {}
21647 
          (_ktype496, _vtype497, _size495 ) = iprot.readMapBegin()
21648 
          for _i499 in xrange(_size495):
21649 
            _key500 = iprot.readI64();
21650 
            _val501 = Item()
21651 
            _val501.read(iprot)
21652 
            self.item[_key500] = _val501
21653 
          iprot.readMapEnd()
21654 
        else:
21655 
          iprot.skip(ftype)
21656 
      else:
21657 
        iprot.skip(ftype)
21658 
      iprot.readFieldEnd()
21659 
    iprot.readStructEnd()
21660 
 
21661 
  def write(self, oprot):
21662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21664 
      return
21665 
    oprot.writeStructBegin('updateAsin_args')
21666 
    if self.item is not None:
21667 
      oprot.writeFieldBegin('item', TType.MAP, 1)
21668 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
21669 
      for kiter502,viter503 in self.item.items():
21670 
        oprot.writeI64(kiter502)
21671 
        viter503.write(oprot)
21672 
      oprot.writeMapEnd()
21673 
      oprot.writeFieldEnd()
21674 
    oprot.writeFieldStop()
21675 
    oprot.writeStructEnd()
21676 
 
21677 
  def validate(self):
21678 
    return
21679 
 
21680 
 
21681 
  def __repr__(self):
21682 
    L = ['%s=%r' % (key, value)
21683 
      for key, value in self.__dict__.iteritems()]
21684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21685 
 
21686 
  def __eq__(self, other):
21687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21688 
 
21689 
  def __ne__(self, other):
21690 
    return not (self == other)
21691 
 
21692 
class updateAsin_result:
21693 
 
21694 
  thrift_spec = (
21695 
  )
21696 
 
21697 
  def read(self, iprot):
21698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21700 
      return
21701 
    iprot.readStructBegin()
21702 
    while True:
21703 
      (fname, ftype, fid) = iprot.readFieldBegin()
21704 
      if ftype == TType.STOP:
21705 
        break
21706 
      else:
21707 
        iprot.skip(ftype)
21708 
      iprot.readFieldEnd()
21709 
    iprot.readStructEnd()
21710 
 
21711 
  def write(self, oprot):
21712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21714 
      return
21715 
    oprot.writeStructBegin('updateAsin_result')
21716 
    oprot.writeFieldStop()
21717 
    oprot.writeStructEnd()
21718 
 
21719 
  def validate(self):
21720 
    return
21721 
 
21722 
 
21723 
  def __repr__(self):
21724 
    L = ['%s=%r' % (key, value)
21725 
      for key, value in self.__dict__.iteritems()]
21726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21727 
 
21728 
  def __eq__(self, other):
21729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21730 
 
21731 
  def __ne__(self, other):
21732 
    return not (self == other)