Subversion Repositories SmartDukaan

Rev

Rev 9861 | Rev 9945 | 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 
 
9253 rajveer 120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
9253 rajveer 128 
     - isAndroid
5944 mandeep.dh 129 
    """
130 
    pass
131 
 
132 
  def getAllItemsInRange(self, offset, limit):
133 
    """
134 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
135 
 
136 
    Parameters:
137 
     - offset
138 
     - limit
139 
    """
140 
    pass
141 
 
142 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
143 
    """
144 
    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.
145 
 
146 
    Parameters:
147 
     - itemStatus
148 
     - offset
149 
     - limit
150 
    """
151 
    pass
152 
 
153 
  def getItemCountByStatus(self, useStatus, itemStatus):
154 
    """
155 
    Gets a count of all items by status
156 
 
157 
    Parameters:
158 
     - useStatus
159 
     - itemStatus
160 
    """
161 
    pass
162 
 
163 
  def getBestSellers(self, ):
164 
    pass
165 
 
166 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
167 
    """
168 
    Parameters:
169 
     - beginIndex
170 
     - totalItems
171 
     - brand
172 
     - category
173 
    """
174 
    pass
175 
 
176 
  def getBestSellersCount(self, ):
177 
    pass
178 
 
179 
  def getBestDeals(self, ):
180 
    pass
181 
 
182 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
183 
    """
184 
    Parameters:
185 
     - beginIndex
186 
     - totalItems
187 
     - brand
188 
     - category
189 
    """
190 
    pass
191 
 
192 
  def getBestDealsCount(self, ):
193 
    pass
194 
 
195 
  def getComingSoon(self, ):
196 
    pass
197 
 
198 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
199 
    """
200 
    Parameters:
201 
     - beginIndex
202 
     - totalItems
203 
     - brand
204 
     - category
205 
    """
206 
    pass
207 
 
208 
  def getComingSoonCount(self, ):
209 
    pass
210 
 
211 
  def getLatestArrivals(self, ):
212 
    """
213 
    Returns a list of items sorted in the descending order by start date.
214 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
215 
    """
216 
    pass
217 
 
218 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
219 
    """
220 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
221 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
222 
 
223 
    Parameters:
224 
     - beginIndex
225 
     - totalItems
226 
     - brand
227 
     - categories
228 
    """
229 
    pass
230 
 
231 
  def getLatestArrivalsCount(self, ):
232 
    """
233 
    Get the total number of latest arrivals we are willing to show.
234 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
235 
    """
236 
    pass
237 
 
238 
  def generateNewEntityID(self, ):
239 
    pass
240 
 
241 
  def addCategory(self, category):
242 
    """
243 
    All category related functions
244 
 
245 
    Parameters:
246 
     - category
247 
    """
248 
    pass
249 
 
250 
  def getCategory(self, id):
251 
    """
252 
    Parameters:
253 
     - id
254 
    """
255 
    pass
256 
 
257 
  def getAllCategories(self, ):
258 
    pass
259 
 
260 
  def getAllSimilarItems(self, itemId):
261 
    """
262 
    Returns the list of similar items.
263 
 
264 
    Parameters:
265 
     - itemId
266 
    """
267 
    pass
268 
 
269 
  def addSimilarItem(self, itemId, catalogItemId):
270 
    """
271 
    Adds similar item.
272 
 
273 
    Parameters:
274 
     - itemId
275 
     - catalogItemId
276 
    """
277 
    pass
278 
 
6512 kshitij.so 279 
  def addTag(self, displayName, itemId):
280 
    """
281 
    Tag Related
282 
 
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteEntityTag(self, displayName, itemId):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
     - itemId
294 
    """
295 
    pass
296 
 
297 
  def deleteTag(self, displayName):
298 
    """
299 
    Parameters:
300 
     - displayName
301 
    """
302 
    pass
303 
 
304 
  def getAllTags(self, ):
305 
    pass
306 
 
307 
  def getAllEntitiesByTagName(self, displayName):
308 
    """
309 
    Parameters:
310 
     - displayName
311 
    """
312 
    pass
313 
 
6845 amit.gupta 314 
  def getAllEntityTags(self, ):
315 
    pass
316 
 
8590 kshitij.so 317 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 318 
    """
8579 kshitij.so 319 
    Banner Related
320 
 
6850 kshitij.so 321 
    Parameters:
8590 kshitij.so 322 
     - bannerCongregate
6850 kshitij.so 323 
    """
324 
    pass
325 
 
8579 kshitij.so 326 
  def updateBanner(self, banner):
327 
    """
328 
    Parameters:
329 
     - banner
330 
    """
331 
    pass
332 
 
6850 kshitij.so 333 
  def getAllBanners(self, ):
334 
    pass
335 
 
9155 kshitij.so 336 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 337 
    """
338 
    Parameters:
339 
     - bannerName
9155 kshitij.so 340 
     - bannerType
6850 kshitij.so 341 
    """
342 
    pass
343 
 
9155 kshitij.so 344 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 345 
    """
346 
    Parameters:
347 
     - bannerName
9155 kshitij.so 348 
     - bannerType
6850 kshitij.so 349 
    """
350 
    pass
351 
 
352 
  def getActiveBanners(self, ):
353 
    pass
354 
 
8579 kshitij.so 355 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 356 
    """
357 
    Parameters:
8579 kshitij.so 358 
     - bannerMaps
6849 kshitij.so 359 
    """
360 
    pass
361 
 
8579 kshitij.so 362 
  def updateBannerMap(self, bannerMap):
363 
    """
364 
    Parameters:
365 
     - bannerMap
366 
    """
367 
    pass
368 
 
6849 kshitij.so 369 
  def deleteBannerMap(self, bannerName):
370 
    """
371 
    Parameters:
372 
     - bannerName
373 
    """
374 
    pass
375 
 
9155 kshitij.so 376 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 377 
    """
378 
    Parameters:
379 
     - bannerName
9155 kshitij.so 380 
     - bannerType
6849 kshitij.so 381 
    """
382 
    pass
383 
 
8579 kshitij.so 384 
  def addBannerUri(self, bannerUriMappings):
385 
    """
386 
    Parameters:
387 
     - bannerUriMappings
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
8579 kshitij.so 396 
    """
397 
    pass
398 
 
399 
  def addCampaign(self, campaign):
400 
    """
401 
    Parameters:
402 
     - campaign
403 
    """
404 
    pass
405 
 
406 
  def getCampaigns(self, campaignName):
407 
    """
408 
    Parameters:
409 
     - campaignName
410 
    """
411 
    pass
412 
 
413 
  def deleteCampaign(self, campaignId):
414 
    """
415 
    Parameters:
416 
     - campaignId
417 
    """
418 
    pass
419 
 
420 
  def getAllCampaigns(self, ):
421 
    pass
422 
 
9155 kshitij.so 423 
  def getActiveBannersForMobileSite(self, ):
424 
    pass
425 
 
5944 mandeep.dh 426 
  def deleteSimilarItem(self, itemId, catalogItemId):
427 
    """
428 
    Delete similar item.
429 
 
430 
    Parameters:
431 
     - itemId
432 
     - catalogItemId
433 
    """
434 
    pass
435 
 
436 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
437 
    """
438 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
439 
    If yes, returns the itemId else returns 0
440 
 
441 
    Parameters:
442 
     - brand
443 
     - modelNumber
444 
     - modelName
445 
     - color
446 
    """
447 
    pass
448 
 
449 
  def validateRiskyStatus(self, itemId):
450 
    """
451 
    Check wether item is risky and change status if inventory is not available for risky items
452 
 
453 
    Parameters:
454 
     - itemId
455 
    """
456 
    pass
457 
 
458 
  def changeItemRiskyFlag(self, itemId, risky):
459 
    """
460 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
461 
 
462 
    Parameters:
463 
     - itemId
464 
     - risky
465 
    """
466 
    pass
467 
 
468 
  def getItemsByRiskyFlag(self, ):
469 
    """
470 
    Returns list of items marked as risky.
471 
    """
472 
    pass
473 
 
474 
  def getItemsForMasterSheet(self, category, brand):
475 
    """
476 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
477 
 
478 
    Parameters:
479 
     - category
480 
     - brand
481 
    """
482 
    pass
483 
 
484 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
485 
    """
486 
    Returns list of catalog ids of items with same similarity index as of the given itemId
487 
 
488 
    Parameters:
489 
     - beginIndex
490 
     - totalItems
491 
     - itemId
492 
    """
493 
    pass
494 
 
495 
  def addProductNotification(self, itemId, email):
496 
    """
497 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
498 
 
499 
    Parameters:
500 
     - itemId
501 
     - email
502 
    """
503 
    pass
504 
 
505 
  def sendProductNotifications(self, ):
506 
    """
507 
    Send the product notifications to the users for items which has stock.
508 
    """
509 
    pass
510 
 
511 
  def getAllBrandsByCategory(self, categoryId):
512 
    """
513 
    Returns list of brand names for a given category Id
514 
 
515 
    Parameters:
516 
     - categoryId
517 
    """
518 
    pass
519 
 
520 
  def getAllBrands(self, ):
521 
    """
522 
    Returns list of brand names
523 
    """
524 
    pass
525 
 
526 
  def getAllSources(self, ):
527 
    """
528 
    Return list of all sources
529 
    """
530 
    pass
531 
 
532 
  def getItemPricingBySource(self, itemId, sourceId):
533 
    """
534 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
535 
 
536 
    Parameters:
537 
     - itemId
538 
     - sourceId
539 
    """
540 
    pass
541 
 
542 
  def addSourceItemPricing(self, sourceItemPricing):
543 
    """
544 
    Adds prices to be displayed corresponding to the item if user comes from a source.
545 
    If item is not found or source is not found, it will throw exception.
546 
 
547 
    Parameters:
548 
     - sourceItemPricing
549 
    """
550 
    pass
551 
 
552 
  def getAllSourcePricing(self, itemId):
553 
    """
554 
    Returns the list of source pricing information of an item.
555 
    Raises an exception if item not found corresponding to itemId
556 
 
557 
    Parameters:
558 
     - itemId
559 
    """
560 
    pass
561 
 
562 
  def getItemForSource(self, item_id, sourceId):
563 
    """
564 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
565 
 
566 
    Parameters:
567 
     - item_id
568 
     - sourceId
569 
    """
570 
    pass
571 
 
572 
  def searchItemsInRange(self, searchTerms, offset, limit):
573 
    """
574 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
575 
 
576 
    Parameters:
577 
     - searchTerms
578 
     - offset
579 
     - limit
580 
    """
581 
    pass
582 
 
583 
  def getSearchResultCount(self, searchTerms):
584 
    """
585 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
586 
 
587 
    Parameters:
588 
     - searchTerms
589 
    """
590 
    pass
591 
 
592 
  def getProductNotifications(self, startDateTime):
593 
    """
594 
    Returns a list of product notifications added after a supplied datetime
595 
 
596 
    Parameters:
597 
     - startDateTime
598 
    """
599 
    pass
600 
 
7897 amar.kumar 601 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 602 
    """
603 
    Returns a list of count of requests for product notification against each item
604 
 
605 
    Parameters:
606 
     - startDateTime
7897 amar.kumar 607 
     - categoryId
5944 mandeep.dh 608 
    """
609 
    pass
610 
 
611 
  def addAuthorizationLog(self, itemId, username, reason):
612 
    """
613 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
614 
 
615 
    Parameters:
616 
     - itemId
617 
     - username
618 
     - reason
619 
    """
620 
    pass
621 
 
622 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
623 
    """
624 
    Parameters:
625 
     - catalog_item_id
626 
     - voucherType
627 
     - voucherAmount
628 
    """
629 
    pass
630 
 
631 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
632 
    """
633 
    Parameters:
634 
     - catalog_item_id
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getVoucherAmount(self, itemId, voucherType):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
     - voucherType
644 
    """
645 
    pass
646 
 
647 
  def getAllItemVouchers(self, itemId):
648 
    """
649 
    Parameters:
650 
     - itemId
651 
    """
652 
    pass
653 
 
654 
  def isValidCatalogItemId(self, catalog_item_id):
655 
    """
656 
    Parameters:
657 
     - catalog_item_id
658 
    """
659 
    pass
660 
 
7330 amit.gupta 661 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 662 
    """
663 
    Parameters:
664 
     - itemId
7330 amit.gupta 665 
     - stateId
6039 amit.gupta 666 
     - price
667 
    """
668 
    pass
5944 mandeep.dh 669 
 
6039 amit.gupta 670 
  def getVatAmountForItem(self, itemId, price):
671 
    """
672 
    Parameters:
673 
     - itemId
674 
     - price
675 
    """
676 
    pass
677 
 
6531 vikram.rag 678 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
679 
    """
680 
    Parameters:
681 
     - offset
682 
     - limit
683 
    """
684 
    pass
6039 amit.gupta 685 
 
6821 amar.kumar 686 
  def getAllAliveItems(self, ):
687 
    pass
688 
 
6921 anupam.sin 689 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 690 
    """
691 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 692 
 
6805 anupam.sin 693 
    Parameters:
694 
     - itemId
6921 anupam.sin 695 
     - price
6805 anupam.sin 696 
     - insurerId
697 
     - quantity
698 
    """
699 
    pass
700 
 
701 
  def getInsurer(self, insurerId):
702 
    """
703 
    Parameters:
704 
     - insurerId
705 
    """
706 
    pass
707 
 
6838 vikram.rag 708 
  def getAllInsurers(self, ):
709 
    pass
6805 anupam.sin 710 
 
6962 rajveer 711 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
712 
    """
713 
    Parameters:
714 
     - insurerId
715 
     - amount
716 
    """
717 
    pass
6838 vikram.rag 718 
 
7190 amar.kumar 719 
  def getFreebieForItem(self, itemId):
720 
    """
721 
    Parameters:
722 
     - itemId
723 
    """
724 
    pass
6962 rajveer 725 
 
7190 amar.kumar 726 
  def addOrUpdateFreebieForItem(self, freebieItem):
727 
    """
728 
    Parameters:
729 
     - freebieItem
730 
    """
731 
    pass
732 
 
7272 amit.gupta 733 
  def addOrUpdateBrandInfo(self, brandInfo):
734 
    """
735 
    Parameters:
736 
     - brandInfo
737 
    """
738 
    pass
739 
 
740 
  def getBrandInfo(self, ):
741 
    pass
742 
 
7256 rajveer 743 
  def getStorePricing(self, itemId):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
    """
748 
    pass
7190 amar.kumar 749 
 
7306 rajveer 750 
  def getStorePricings(self, itemIds):
751 
    """
752 
    Parameters:
753 
     - itemIds
754 
    """
755 
    pass
756 
 
7382 rajveer 757 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 758 
    """
759 
    Parameters:
760 
     - sp
7382 rajveer 761 
     - allColors
7265 rajveer 762 
    """
763 
    pass
7256 rajveer 764 
 
7281 kshitij.so 765 
  def getAllAmazonListedItems(self, ):
766 
    pass
7265 rajveer 767 
 
8619 kshitij.so 768 
  def searchAmazonItems(self, searchTerm, offset, limit):
769 
    """
770 
    Parameters:
771 
     - searchTerm
772 
     - offset
773 
     - limit
774 
    """
775 
    pass
776 
 
777 
  def getAmazonSearchResultCount(self, searchTerm):
778 
    """
779 
    Parameters:
780 
     - searchTerm
781 
    """
782 
    pass
783 
 
784 
  def getCountForAmazonlistedItems(self, ):
785 
    pass
786 
 
7281 kshitij.so 787 
  def getAmazonItemDetails(self, itemId):
788 
    """
789 
    Parameters:
790 
     - itemId
791 
    """
792 
    pass
793 
 
8168 kshitij.so 794 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 795 
    """
796 
    Parameters:
8168 kshitij.so 797 
     - amazonlisted
7281 kshitij.so 798 
    """
799 
    pass
800 
 
801 
  def addAmazonItem(self, amazonlisted):
802 
    """
803 
    Parameters:
804 
     - amazonlisted
805 
    """
806 
    pass
807 
 
7291 vikram.rag 808 
  def getAsinItems(self, ):
809 
    pass
7281 kshitij.so 810 
 
7291 vikram.rag 811 
  def getAllFbaListedItems(self, ):
812 
    pass
813 
 
814 
  def getAllNonFbaListedItems(self, ):
815 
    pass
816 
 
7460 kshitij.so 817 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
818 
    """
819 
    Parameters:
820 
     - itemId
821 
     - holdInventory
822 
     - defaultInventory
823 
    """
824 
    pass
7291 vikram.rag 825 
 
7770 kshitij.so 826 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
827 
    """
828 
    Parameters:
829 
     - type
830 
     - sku
831 
     - timestamp
832 
    """
833 
    pass
7460 kshitij.so 834 
 
7897 amar.kumar 835 
  def getAllParentCategories(self, ):
836 
    pass
7770 kshitij.so 837 
 
7977 kshitij.so 838 
  def addPageViewEvent(self, pageViewEvents):
839 
    """
840 
    Parameters:
841 
     - pageViewEvents
842 
    """
843 
    pass
7897 amar.kumar 844 
 
7977 kshitij.so 845 
  def addCartEvent(self, cartEvents):
846 
    """
847 
    Parameters:
848 
     - cartEvents
849 
    """
850 
    pass
851 
 
8182 amar.kumar 852 
  def addEbayItem(self, ebayItem):
853 
    """
854 
    Parameters:
855 
     - ebayItem
856 
    """
857 
    pass
858 
 
859 
  def getEbayItem(self, listingId):
860 
    """
861 
    Parameters:
862 
     - listingId
863 
    """
864 
    pass
865 
 
866 
  def updateEbayItem(self, ebayItem):
867 
    """
868 
    Parameters:
869 
     - ebayItem
870 
    """
871 
    pass
872 
 
8139 kshitij.so 873 
  def getAmazonListedItems(self, offset, limit):
874 
    """
875 
    Parameters:
876 
     - offset
877 
     - limit
878 
    """
879 
    pass
7977 kshitij.so 880 
 
8168 kshitij.so 881 
  def updateAmazonAttributesInBulk(self, amazonlisted):
882 
    """
883 
    Parameters:
884 
     - amazonlisted
885 
    """
886 
    pass
8139 kshitij.so 887 
 
8379 vikram.rag 888 
  def getAllItemstoListOnFba(self, ):
889 
    pass
8168 kshitij.so 890 
 
8379 vikram.rag 891 
  def getAllItemstoListOnNonFba(self, ):
892 
    pass
893 
 
8619 kshitij.so 894 
  def updateAsin(self, item):
895 
    """
896 
    Parameters:
897 
     - item
898 
    """
899 
    pass
8616 vikram.rag 900 
 
8739 vikram.rag 901 
  def addOrUpdateSnapdealItem(self, snapdealitem):
902 
    """
903 
    Parameters:
904 
     - snapdealitem
905 
    """
906 
    pass
8619 kshitij.so 907 
 
8739 vikram.rag 908 
  def getSnapdealItem(self, item_id):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
    """
913 
    pass
914 
 
9242 kshitij.so 915 
  def getSnapdealItemDetails(self, item_id):
916 
    """
917 
    Parameters:
918 
     - item_id
919 
    """
920 
    pass
921 
 
8739 vikram.rag 922 
  def getAllSnapdealItems(self, ):
923 
    pass
924 
 
9242 kshitij.so 925 
  def getSnapdealItems(self, offset, limit):
926 
    """
927 
    Parameters:
928 
     - offset
929 
     - limit
930 
    """
931 
    pass
8739 vikram.rag 932 
 
9242 kshitij.so 933 
  def searchSnapdealItems(self, searchTerm, offset, limit):
934 
    """
935 
    Parameters:
936 
     - searchTerm
937 
     - offset
938 
     - limit
939 
    """
940 
    pass
941 
 
942 
  def getCountForSnapdealItems(self, ):
943 
    pass
944 
 
945 
  def getSnapdealSearchResultCount(self, searchTerm):
946 
    """
947 
    Parameters:
948 
     - searchTerm
949 
    """
950 
    pass
951 
 
9299 kshitij.so 952 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
     - insurerType
957 
    """
958 
    pass
9242 kshitij.so 959 
 
9456 vikram.rag 960 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
961 
    """
962 
    Parameters:
963 
     - skuAtSnapdeal
964 
    """
965 
    pass
9299 kshitij.so 966 
 
9621 manish.sha 967 
  def getProductFeedSubmit(self, catalogItemId):
968 
    """
969 
    Parameters:
970 
     - catalogItemId
971 
    """
972 
    pass
9456 vikram.rag 973 
 
9621 manish.sha 974 
  def addProductFeedSubmit(self, productFeedSubmit):
975 
    """
976 
    Parameters:
977 
     - productFeedSubmit
978 
    """
979 
    pass
980 
 
981 
  def updateProductFeedSubmit(self, productFeedSubmit):
982 
    """
983 
    Parameters:
984 
     - productFeedSubmit
985 
    """
986 
    pass
987 
 
988 
  def deleteProductFeedSubmit(self, catalogItemId):
989 
    """
990 
    Parameters:
991 
     - catalogItemId
992 
    """
993 
    pass
994 
 
995 
  def getAllProductFeedSubmit(self, ):
996 
    pass
997 
 
9724 kshitij.so 998 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
999 
    """
1000 
    Parameters:
1001 
     - itemId
1002 
     - sourceId
1003 
    """
1004 
    pass
9621 manish.sha 1005 
 
9724 kshitij.so 1006 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
1007 
    """
1008 
    Parameters:
1009 
     - marketPlaceItem
1010 
    """
1011 
    pass
1012 
 
9779 kshitij.so 1013 
  def getCostingForMarketplace(self, source, item_id):
1014 
    """
1015 
    Parameters:
1016 
     - source
1017 
     - item_id
1018 
    """
1019 
    pass
1020 
 
9776 vikram.rag 1021 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1022 
    """
1023 
    Parameters:
1024 
     - source
1025 
    """
1026 
    pass
9724 kshitij.so 1027 
 
9816 kshitij.so 1028 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 1029 
    """
1030 
    Parameters:
1031 
     - skulist
1032 
     - timestamp
9816 kshitij.so 1033 
     - source
9776 vikram.rag 1034 
    """
1035 
    pass
1036 
 
9861 rajveer 1037 
  def updateItemHoldInventory(self, itemHoldMap):
1038 
    """
1039 
    Parameters:
1040 
     - itemHoldMap
1041 
    """
1042 
    pass
9776 vikram.rag 1043 
 
9895 vikram.rag 1044 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
1045 
    """
1046 
    Parameters:
1047 
     - item_id
1048 
     - vendor_id
1049 
     - nlc
1050 
    """
1051 
    pass
9861 rajveer 1052 
 
9895 vikram.rag 1053 
 
5944 mandeep.dh 1054 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1055 
  def __init__(self, iprot, oprot=None):
1056 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1057 
 
1058 
  def addItem(self, item):
1059 
    """
1060 
    Availability and inventory attributes
1061 
 
1062 
    Parameters:
1063 
     - item
1064 
    """
1065 
    self.send_addItem(item)
1066 
    return self.recv_addItem()
1067 
 
1068 
  def send_addItem(self, item):
1069 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1070 
    args = addItem_args()
1071 
    args.item = item
1072 
    args.write(self._oprot)
1073 
    self._oprot.writeMessageEnd()
1074 
    self._oprot.trans.flush()
1075 
 
1076 
  def recv_addItem(self, ):
1077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1078 
    if mtype == TMessageType.EXCEPTION:
1079 
      x = TApplicationException()
1080 
      x.read(self._iprot)
1081 
      self._iprot.readMessageEnd()
1082 
      raise x
1083 
    result = addItem_result()
1084 
    result.read(self._iprot)
1085 
    self._iprot.readMessageEnd()
1086 
    if result.success is not None:
1087 
      return result.success
1088 
    if result.cex is not None:
1089 
      raise result.cex
1090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1091 
 
1092 
  def updateItem(self, item):
1093 
    """
1094 
    Parameters:
1095 
     - item
1096 
    """
1097 
    self.send_updateItem(item)
1098 
    return self.recv_updateItem()
1099 
 
1100 
  def send_updateItem(self, item):
1101 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1102 
    args = updateItem_args()
1103 
    args.item = item
1104 
    args.write(self._oprot)
1105 
    self._oprot.writeMessageEnd()
1106 
    self._oprot.trans.flush()
1107 
 
1108 
  def recv_updateItem(self, ):
1109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1110 
    if mtype == TMessageType.EXCEPTION:
1111 
      x = TApplicationException()
1112 
      x.read(self._iprot)
1113 
      self._iprot.readMessageEnd()
1114 
      raise x
1115 
    result = updateItem_result()
1116 
    result.read(self._iprot)
1117 
    self._iprot.readMessageEnd()
1118 
    if result.success is not None:
1119 
      return result.success
1120 
    if result.cex is not None:
1121 
      raise result.cex
1122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1123 
 
1124 
  def isActive(self, itemId):
1125 
    """
1126 
    Checks if the item given to the corresponding itemId is active. If it's active,
1127 
    whether it's risky and if it's risky, its inventory position.
1128 
 
1129 
    Parameters:
1130 
     - itemId
1131 
    """
1132 
    self.send_isActive(itemId)
1133 
    return self.recv_isActive()
1134 
 
1135 
  def send_isActive(self, itemId):
1136 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1137 
    args = isActive_args()
1138 
    args.itemId = itemId
1139 
    args.write(self._oprot)
1140 
    self._oprot.writeMessageEnd()
1141 
    self._oprot.trans.flush()
1142 
 
1143 
  def recv_isActive(self, ):
1144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1145 
    if mtype == TMessageType.EXCEPTION:
1146 
      x = TApplicationException()
1147 
      x.read(self._iprot)
1148 
      self._iprot.readMessageEnd()
1149 
      raise x
1150 
    result = isActive_result()
1151 
    result.read(self._iprot)
1152 
    self._iprot.readMessageEnd()
1153 
    if result.success is not None:
1154 
      return result.success
1155 
    if result.isex is not None:
1156 
      raise result.isex
1157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1158 
 
7438 amit.gupta 1159 
  def getItemsStatus(self, itemIds):
1160 
    """
1161 
    Parameters:
1162 
     - itemIds
1163 
    """
1164 
    self.send_getItemsStatus(itemIds)
1165 
    return self.recv_getItemsStatus()
1166 
 
1167 
  def send_getItemsStatus(self, itemIds):
1168 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1169 
    args = getItemsStatus_args()
1170 
    args.itemIds = itemIds
1171 
    args.write(self._oprot)
1172 
    self._oprot.writeMessageEnd()
1173 
    self._oprot.trans.flush()
1174 
 
1175 
  def recv_getItemsStatus(self, ):
1176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1177 
    if mtype == TMessageType.EXCEPTION:
1178 
      x = TApplicationException()
1179 
      x.read(self._iprot)
1180 
      self._iprot.readMessageEnd()
1181 
      raise x
1182 
    result = getItemsStatus_result()
1183 
    result.read(self._iprot)
1184 
    self._iprot.readMessageEnd()
1185 
    if result.success is not None:
1186 
      return result.success
1187 
    if result.isex is not None:
1188 
      raise result.isex
1189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1190 
 
5944 mandeep.dh 1191 
  def getItemStatusDescription(self, itemId):
1192 
    """
1193 
    Parameters:
1194 
     - itemId
1195 
    """
1196 
    self.send_getItemStatusDescription(itemId)
1197 
    return self.recv_getItemStatusDescription()
1198 
 
1199 
  def send_getItemStatusDescription(self, itemId):
1200 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1201 
    args = getItemStatusDescription_args()
1202 
    args.itemId = itemId
1203 
    args.write(self._oprot)
1204 
    self._oprot.writeMessageEnd()
1205 
    self._oprot.trans.flush()
1206 
 
1207 
  def recv_getItemStatusDescription(self, ):
1208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1209 
    if mtype == TMessageType.EXCEPTION:
1210 
      x = TApplicationException()
1211 
      x.read(self._iprot)
1212 
      self._iprot.readMessageEnd()
1213 
      raise x
1214 
    result = getItemStatusDescription_result()
1215 
    result.read(self._iprot)
1216 
    self._iprot.readMessageEnd()
1217 
    if result.success is not None:
1218 
      return result.success
1219 
    if result.isex is not None:
1220 
      raise result.isex
1221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1222 
 
1223 
  def startItemOn(self, item_id, timestamp):
1224 
    """
1225 
    Parameters:
1226 
     - item_id
1227 
     - timestamp
1228 
    """
1229 
    self.send_startItemOn(item_id, timestamp)
1230 
    self.recv_startItemOn()
1231 
 
1232 
  def send_startItemOn(self, item_id, timestamp):
1233 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1234 
    args = startItemOn_args()
1235 
    args.item_id = item_id
1236 
    args.timestamp = timestamp
1237 
    args.write(self._oprot)
1238 
    self._oprot.writeMessageEnd()
1239 
    self._oprot.trans.flush()
1240 
 
1241 
  def recv_startItemOn(self, ):
1242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1243 
    if mtype == TMessageType.EXCEPTION:
1244 
      x = TApplicationException()
1245 
      x.read(self._iprot)
1246 
      self._iprot.readMessageEnd()
1247 
      raise x
1248 
    result = startItemOn_result()
1249 
    result.read(self._iprot)
1250 
    self._iprot.readMessageEnd()
1251 
    if result.cex is not None:
1252 
      raise result.cex
1253 
    return
1254 
 
1255 
  def retireItemOn(self, item_id, timestamp):
1256 
    """
1257 
    Parameters:
1258 
     - item_id
1259 
     - timestamp
1260 
    """
1261 
    self.send_retireItemOn(item_id, timestamp)
1262 
    self.recv_retireItemOn()
1263 
 
1264 
  def send_retireItemOn(self, item_id, timestamp):
1265 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1266 
    args = retireItemOn_args()
1267 
    args.item_id = item_id
1268 
    args.timestamp = timestamp
1269 
    args.write(self._oprot)
1270 
    self._oprot.writeMessageEnd()
1271 
    self._oprot.trans.flush()
1272 
 
1273 
  def recv_retireItemOn(self, ):
1274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1275 
    if mtype == TMessageType.EXCEPTION:
1276 
      x = TApplicationException()
1277 
      x.read(self._iprot)
1278 
      self._iprot.readMessageEnd()
1279 
      raise x
1280 
    result = retireItemOn_result()
1281 
    result.read(self._iprot)
1282 
    self._iprot.readMessageEnd()
1283 
    if result.cex is not None:
1284 
      raise result.cex
1285 
    return
1286 
 
1287 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1288 
    """
1289 
    Parameters:
1290 
     - item_id
1291 
     - timestamp
1292 
     - newstatus
1293 
    """
1294 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1295 
    self.recv_changeItemStatus()
1296 
 
1297 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1298 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1299 
    args = changeItemStatus_args()
1300 
    args.item_id = item_id
1301 
    args.timestamp = timestamp
1302 
    args.newstatus = newstatus
1303 
    args.write(self._oprot)
1304 
    self._oprot.writeMessageEnd()
1305 
    self._oprot.trans.flush()
1306 
 
1307 
  def recv_changeItemStatus(self, ):
1308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1309 
    if mtype == TMessageType.EXCEPTION:
1310 
      x = TApplicationException()
1311 
      x.read(self._iprot)
1312 
      self._iprot.readMessageEnd()
1313 
      raise x
1314 
    result = changeItemStatus_result()
1315 
    result.read(self._iprot)
1316 
    self._iprot.readMessageEnd()
1317 
    if result.cex is not None:
1318 
      raise result.cex
1319 
    return
1320 
 
1321 
  def getItem(self, item_id):
1322 
    """
1323 
    Parameters:
1324 
     - item_id
1325 
    """
1326 
    self.send_getItem(item_id)
1327 
    return self.recv_getItem()
1328 
 
1329 
  def send_getItem(self, item_id):
1330 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1331 
    args = getItem_args()
1332 
    args.item_id = item_id
1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_getItem(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = getItem_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
1347 
    if result.success is not None:
1348 
      return result.success
1349 
    if result.cex is not None:
1350 
      raise result.cex
1351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1352 
 
1353 
  def getItemsByCatalogId(self, catalog_item_id):
1354 
    """
1355 
    Parameters:
1356 
     - catalog_item_id
1357 
    """
1358 
    self.send_getItemsByCatalogId(catalog_item_id)
1359 
    return self.recv_getItemsByCatalogId()
1360 
 
1361 
  def send_getItemsByCatalogId(self, catalog_item_id):
1362 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1363 
    args = getItemsByCatalogId_args()
1364 
    args.catalog_item_id = catalog_item_id
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_getItemsByCatalogId(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = getItemsByCatalogId_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
1379 
    if result.success is not None:
1380 
      return result.success
1381 
    if result.cex is not None:
1382 
      raise result.cex
1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1384 
 
1385 
  def getValidItemsByCatalogId(self, catalog_item_id):
1386 
    """
1387 
    Parameters:
1388 
     - catalog_item_id
1389 
    """
1390 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1391 
    return self.recv_getValidItemsByCatalogId()
1392 
 
1393 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1394 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1395 
    args = getValidItemsByCatalogId_args()
1396 
    args.catalog_item_id = catalog_item_id
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getValidItemsByCatalogId(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getValidItemsByCatalogId_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success is not None:
1412 
      return result.success
1413 
    if result.cex is not None:
1414 
      raise result.cex
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1416 
 
1417 
  def getAllItems(self, isActive):
1418 
    """
1419 
    Parameters:
1420 
     - isActive
1421 
    """
1422 
    self.send_getAllItems(isActive)
1423 
    return self.recv_getAllItems()
1424 
 
1425 
  def send_getAllItems(self, isActive):
1426 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1427 
    args = getAllItems_args()
1428 
    args.isActive = isActive
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getAllItems(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getAllItems_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success is not None:
1444 
      return result.success
1445 
    if result.cex is not None:
1446 
      raise result.cex
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1448 
 
1449 
  def getAllItemsByStatus(self, itemStatus):
1450 
    """
1451 
    Parameters:
1452 
     - itemStatus
1453 
    """
1454 
    self.send_getAllItemsByStatus(itemStatus)
1455 
    return self.recv_getAllItemsByStatus()
1456 
 
1457 
  def send_getAllItemsByStatus(self, itemStatus):
1458 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1459 
    args = getAllItemsByStatus_args()
1460 
    args.itemStatus = itemStatus
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_getAllItemsByStatus(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = getAllItemsByStatus_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
1475 
    if result.success is not None:
1476 
      return result.success
1477 
    if result.cex is not None:
1478 
      raise result.cex
1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1480 
 
9253 rajveer 1481 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1482 
    """
1483 
    Parameters:
1484 
     - entityId
1485 
     - category
1486 
     - brand
1487 
     - modelName
1488 
     - modelNumber
9253 rajveer 1489 
     - isAndroid
5944 mandeep.dh 1490 
    """
9253 rajveer 1491 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1492 
    return self.recv_markItemAsContentComplete()
1493 
 
9253 rajveer 1494 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1495 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1496 
    args = markItemAsContentComplete_args()
1497 
    args.entityId = entityId
1498 
    args.category = category
1499 
    args.brand = brand
1500 
    args.modelName = modelName
1501 
    args.modelNumber = modelNumber
9253 rajveer 1502 
    args.isAndroid = isAndroid
5944 mandeep.dh 1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_markItemAsContentComplete(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = markItemAsContentComplete_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
1517 
    if result.success is not None:
1518 
      return result.success
1519 
    if result.cex is not None:
1520 
      raise result.cex
1521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1522 
 
1523 
  def getAllItemsInRange(self, offset, limit):
1524 
    """
1525 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1526 
 
1527 
    Parameters:
1528 
     - offset
1529 
     - limit
1530 
    """
1531 
    self.send_getAllItemsInRange(offset, limit)
1532 
    return self.recv_getAllItemsInRange()
1533 
 
1534 
  def send_getAllItemsInRange(self, offset, limit):
1535 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1536 
    args = getAllItemsInRange_args()
1537 
    args.offset = offset
1538 
    args.limit = limit
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_getAllItemsInRange(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = getAllItemsInRange_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    if result.success is not None:
1554 
      return result.success
1555 
    if result.cex is not None:
1556 
      raise result.cex
1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1558 
 
1559 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1560 
    """
1561 
    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.
1562 
 
1563 
    Parameters:
1564 
     - itemStatus
1565 
     - offset
1566 
     - limit
1567 
    """
1568 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1569 
    return self.recv_getAllItemsByStatusInRange()
1570 
 
1571 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1572 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1573 
    args = getAllItemsByStatusInRange_args()
1574 
    args.itemStatus = itemStatus
1575 
    args.offset = offset
1576 
    args.limit = limit
1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
1581 
  def recv_getAllItemsByStatusInRange(self, ):
1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
1588 
    result = getAllItemsByStatusInRange_result()
1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
1591 
    if result.success is not None:
1592 
      return result.success
1593 
    if result.cex is not None:
1594 
      raise result.cex
1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1596 
 
1597 
  def getItemCountByStatus(self, useStatus, itemStatus):
1598 
    """
1599 
    Gets a count of all items by status
1600 
 
1601 
    Parameters:
1602 
     - useStatus
1603 
     - itemStatus
1604 
    """
1605 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1606 
    return self.recv_getItemCountByStatus()
1607 
 
1608 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1609 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1610 
    args = getItemCountByStatus_args()
1611 
    args.useStatus = useStatus
1612 
    args.itemStatus = itemStatus
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getItemCountByStatus(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getItemCountByStatus_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
1627 
    if result.success is not None:
1628 
      return result.success
1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1630 
 
1631 
  def getBestSellers(self, ):
1632 
    self.send_getBestSellers()
1633 
    return self.recv_getBestSellers()
1634 
 
1635 
  def send_getBestSellers(self, ):
1636 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1637 
    args = getBestSellers_args()
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getBestSellers(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getBestSellers_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
1652 
    if result.success is not None:
1653 
      return result.success
1654 
    if result.isex is not None:
1655 
      raise result.isex
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1657 
 
1658 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1659 
    """
1660 
    Parameters:
1661 
     - beginIndex
1662 
     - totalItems
1663 
     - brand
1664 
     - category
1665 
    """
1666 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1667 
    return self.recv_getBestSellersCatalogIds()
1668 
 
1669 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1670 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1671 
    args = getBestSellersCatalogIds_args()
1672 
    args.beginIndex = beginIndex
1673 
    args.totalItems = totalItems
1674 
    args.brand = brand
1675 
    args.category = category
1676 
    args.write(self._oprot)
1677 
    self._oprot.writeMessageEnd()
1678 
    self._oprot.trans.flush()
1679 
 
1680 
  def recv_getBestSellersCatalogIds(self, ):
1681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1682 
    if mtype == TMessageType.EXCEPTION:
1683 
      x = TApplicationException()
1684 
      x.read(self._iprot)
1685 
      self._iprot.readMessageEnd()
1686 
      raise x
1687 
    result = getBestSellersCatalogIds_result()
1688 
    result.read(self._iprot)
1689 
    self._iprot.readMessageEnd()
1690 
    if result.success is not None:
1691 
      return result.success
1692 
    if result.cex is not None:
1693 
      raise result.cex
1694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1695 
 
1696 
  def getBestSellersCount(self, ):
1697 
    self.send_getBestSellersCount()
1698 
    return self.recv_getBestSellersCount()
1699 
 
1700 
  def send_getBestSellersCount(self, ):
1701 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1702 
    args = getBestSellersCount_args()
1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_getBestSellersCount(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = getBestSellersCount_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
1717 
    if result.success is not None:
1718 
      return result.success
1719 
    if result.cex is not None:
1720 
      raise result.cex
1721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1722 
 
1723 
  def getBestDeals(self, ):
1724 
    self.send_getBestDeals()
1725 
    return self.recv_getBestDeals()
1726 
 
1727 
  def send_getBestDeals(self, ):
1728 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1729 
    args = getBestDeals_args()
1730 
    args.write(self._oprot)
1731 
    self._oprot.writeMessageEnd()
1732 
    self._oprot.trans.flush()
1733 
 
1734 
  def recv_getBestDeals(self, ):
1735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1736 
    if mtype == TMessageType.EXCEPTION:
1737 
      x = TApplicationException()
1738 
      x.read(self._iprot)
1739 
      self._iprot.readMessageEnd()
1740 
      raise x
1741 
    result = getBestDeals_result()
1742 
    result.read(self._iprot)
1743 
    self._iprot.readMessageEnd()
1744 
    if result.success is not None:
1745 
      return result.success
1746 
    if result.isex is not None:
1747 
      raise result.isex
1748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1749 
 
1750 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1751 
    """
1752 
    Parameters:
1753 
     - beginIndex
1754 
     - totalItems
1755 
     - brand
1756 
     - category
1757 
    """
1758 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1759 
    return self.recv_getBestDealsCatalogIds()
1760 
 
1761 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1762 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1763 
    args = getBestDealsCatalogIds_args()
1764 
    args.beginIndex = beginIndex
1765 
    args.totalItems = totalItems
1766 
    args.brand = brand
1767 
    args.category = category
1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
1772 
  def recv_getBestDealsCatalogIds(self, ):
1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
1779 
    result = getBestDealsCatalogIds_result()
1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
1782 
    if result.success is not None:
1783 
      return result.success
1784 
    if result.cex is not None:
1785 
      raise result.cex
1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1787 
 
1788 
  def getBestDealsCount(self, ):
1789 
    self.send_getBestDealsCount()
1790 
    return self.recv_getBestDealsCount()
1791 
 
1792 
  def send_getBestDealsCount(self, ):
1793 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1794 
    args = getBestDealsCount_args()
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_getBestDealsCount(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = getBestDealsCount_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
1809 
    if result.success is not None:
1810 
      return result.success
1811 
    if result.cex is not None:
1812 
      raise result.cex
1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1814 
 
1815 
  def getComingSoon(self, ):
1816 
    self.send_getComingSoon()
1817 
    return self.recv_getComingSoon()
1818 
 
1819 
  def send_getComingSoon(self, ):
1820 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1821 
    args = getComingSoon_args()
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_getComingSoon(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = getComingSoon_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.success is not None:
1837 
      return result.success
1838 
    if result.isex is not None:
1839 
      raise result.isex
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1841 
 
1842 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1843 
    """
1844 
    Parameters:
1845 
     - beginIndex
1846 
     - totalItems
1847 
     - brand
1848 
     - category
1849 
    """
1850 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1851 
    return self.recv_getComingSoonCatalogIds()
1852 
 
1853 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1854 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1855 
    args = getComingSoonCatalogIds_args()
1856 
    args.beginIndex = beginIndex
1857 
    args.totalItems = totalItems
1858 
    args.brand = brand
1859 
    args.category = category
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_getComingSoonCatalogIds(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = getComingSoonCatalogIds_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
1874 
    if result.success is not None:
1875 
      return result.success
1876 
    if result.cex is not None:
1877 
      raise result.cex
1878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1879 
 
1880 
  def getComingSoonCount(self, ):
1881 
    self.send_getComingSoonCount()
1882 
    return self.recv_getComingSoonCount()
1883 
 
1884 
  def send_getComingSoonCount(self, ):
1885 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1886 
    args = getComingSoonCount_args()
1887 
    args.write(self._oprot)
1888 
    self._oprot.writeMessageEnd()
1889 
    self._oprot.trans.flush()
1890 
 
1891 
  def recv_getComingSoonCount(self, ):
1892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1893 
    if mtype == TMessageType.EXCEPTION:
1894 
      x = TApplicationException()
1895 
      x.read(self._iprot)
1896 
      self._iprot.readMessageEnd()
1897 
      raise x
1898 
    result = getComingSoonCount_result()
1899 
    result.read(self._iprot)
1900 
    self._iprot.readMessageEnd()
1901 
    if result.success is not None:
1902 
      return result.success
1903 
    if result.cex is not None:
1904 
      raise result.cex
1905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1906 
 
1907 
  def getLatestArrivals(self, ):
1908 
    """
1909 
    Returns a list of items sorted in the descending order by start date.
1910 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1911 
    """
1912 
    self.send_getLatestArrivals()
1913 
    return self.recv_getLatestArrivals()
1914 
 
1915 
  def send_getLatestArrivals(self, ):
1916 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1917 
    args = getLatestArrivals_args()
1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
1922 
  def recv_getLatestArrivals(self, ):
1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
1929 
    result = getLatestArrivals_result()
1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
1932 
    if result.success is not None:
1933 
      return result.success
1934 
    if result.isex is not None:
1935 
      raise result.isex
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1937 
 
1938 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1939 
    """
1940 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1941 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1942 
 
1943 
    Parameters:
1944 
     - beginIndex
1945 
     - totalItems
1946 
     - brand
1947 
     - categories
1948 
    """
1949 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1950 
    return self.recv_getLatestArrivalsCatalogIds()
1951 
 
1952 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1953 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1954 
    args = getLatestArrivalsCatalogIds_args()
1955 
    args.beginIndex = beginIndex
1956 
    args.totalItems = totalItems
1957 
    args.brand = brand
1958 
    args.categories = categories
1959 
    args.write(self._oprot)
1960 
    self._oprot.writeMessageEnd()
1961 
    self._oprot.trans.flush()
1962 
 
1963 
  def recv_getLatestArrivalsCatalogIds(self, ):
1964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1965 
    if mtype == TMessageType.EXCEPTION:
1966 
      x = TApplicationException()
1967 
      x.read(self._iprot)
1968 
      self._iprot.readMessageEnd()
1969 
      raise x
1970 
    result = getLatestArrivalsCatalogIds_result()
1971 
    result.read(self._iprot)
1972 
    self._iprot.readMessageEnd()
1973 
    if result.success is not None:
1974 
      return result.success
1975 
    if result.cex is not None:
1976 
      raise result.cex
1977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1978 
 
1979 
  def getLatestArrivalsCount(self, ):
1980 
    """
1981 
    Get the total number of latest arrivals we are willing to show.
1982 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1983 
    """
1984 
    self.send_getLatestArrivalsCount()
1985 
    return self.recv_getLatestArrivalsCount()
1986 
 
1987 
  def send_getLatestArrivalsCount(self, ):
1988 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1989 
    args = getLatestArrivalsCount_args()
1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
1994 
  def recv_getLatestArrivalsCount(self, ):
1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
2001 
    result = getLatestArrivalsCount_result()
2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
2004 
    if result.success is not None:
2005 
      return result.success
2006 
    if result.cex is not None:
2007 
      raise result.cex
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2009 
 
2010 
  def generateNewEntityID(self, ):
2011 
    self.send_generateNewEntityID()
2012 
    return self.recv_generateNewEntityID()
2013 
 
2014 
  def send_generateNewEntityID(self, ):
2015 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2016 
    args = generateNewEntityID_args()
2017 
    args.write(self._oprot)
2018 
    self._oprot.writeMessageEnd()
2019 
    self._oprot.trans.flush()
2020 
 
2021 
  def recv_generateNewEntityID(self, ):
2022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2023 
    if mtype == TMessageType.EXCEPTION:
2024 
      x = TApplicationException()
2025 
      x.read(self._iprot)
2026 
      self._iprot.readMessageEnd()
2027 
      raise x
2028 
    result = generateNewEntityID_result()
2029 
    result.read(self._iprot)
2030 
    self._iprot.readMessageEnd()
2031 
    if result.success is not None:
2032 
      return result.success
2033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2034 
 
2035 
  def addCategory(self, category):
2036 
    """
2037 
    All category related functions
2038 
 
2039 
    Parameters:
2040 
     - category
2041 
    """
2042 
    self.send_addCategory(category)
2043 
    return self.recv_addCategory()
2044 
 
2045 
  def send_addCategory(self, category):
2046 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2047 
    args = addCategory_args()
2048 
    args.category = category
2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
2053 
  def recv_addCategory(self, ):
2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
2060 
    result = addCategory_result()
2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
2063 
    if result.success is not None:
2064 
      return result.success
2065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2066 
 
2067 
  def getCategory(self, id):
2068 
    """
2069 
    Parameters:
2070 
     - id
2071 
    """
2072 
    self.send_getCategory(id)
2073 
    return self.recv_getCategory()
2074 
 
2075 
  def send_getCategory(self, id):
2076 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2077 
    args = getCategory_args()
2078 
    args.id = id
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_getCategory(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 = getCategory_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, "getCategory failed: unknown result");
2096 
 
2097 
  def getAllCategories(self, ):
2098 
    self.send_getAllCategories()
2099 
    return self.recv_getAllCategories()
2100 
 
2101 
  def send_getAllCategories(self, ):
2102 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2103 
    args = getAllCategories_args()
2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
2108 
  def recv_getAllCategories(self, ):
2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
2115 
    result = getAllCategories_result()
2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
2118 
    if result.success is not None:
2119 
      return result.success
2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2121 
 
2122 
  def getAllSimilarItems(self, itemId):
2123 
    """
2124 
    Returns the list of similar items.
2125 
 
2126 
    Parameters:
2127 
     - itemId
2128 
    """
2129 
    self.send_getAllSimilarItems(itemId)
2130 
    return self.recv_getAllSimilarItems()
2131 
 
2132 
  def send_getAllSimilarItems(self, itemId):
2133 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2134 
    args = getAllSimilarItems_args()
2135 
    args.itemId = itemId
2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
2140 
  def recv_getAllSimilarItems(self, ):
2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
2147 
    result = getAllSimilarItems_result()
2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
2150 
    if result.success is not None:
2151 
      return result.success
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2153 
 
2154 
  def addSimilarItem(self, itemId, catalogItemId):
2155 
    """
2156 
    Adds similar item.
2157 
 
2158 
    Parameters:
2159 
     - itemId
2160 
     - catalogItemId
2161 
    """
2162 
    self.send_addSimilarItem(itemId, catalogItemId)
2163 
    return self.recv_addSimilarItem()
2164 
 
2165 
  def send_addSimilarItem(self, itemId, catalogItemId):
2166 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2167 
    args = addSimilarItem_args()
2168 
    args.itemId = itemId
2169 
    args.catalogItemId = catalogItemId
2170 
    args.write(self._oprot)
2171 
    self._oprot.writeMessageEnd()
2172 
    self._oprot.trans.flush()
2173 
 
2174 
  def recv_addSimilarItem(self, ):
2175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2176 
    if mtype == TMessageType.EXCEPTION:
2177 
      x = TApplicationException()
2178 
      x.read(self._iprot)
2179 
      self._iprot.readMessageEnd()
2180 
      raise x
2181 
    result = addSimilarItem_result()
2182 
    result.read(self._iprot)
2183 
    self._iprot.readMessageEnd()
2184 
    if result.success is not None:
2185 
      return result.success
2186 
    if result.cex is not None:
2187 
      raise result.cex
2188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2189 
 
6512 kshitij.so 2190 
  def addTag(self, displayName, itemId):
2191 
    """
2192 
    Tag Related
2193 
 
2194 
    Parameters:
2195 
     - displayName
2196 
     - itemId
2197 
    """
2198 
    self.send_addTag(displayName, itemId)
2199 
    return self.recv_addTag()
2200 
 
2201 
  def send_addTag(self, displayName, itemId):
2202 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2203 
    args = addTag_args()
2204 
    args.displayName = displayName
2205 
    args.itemId = itemId
2206 
    args.write(self._oprot)
2207 
    self._oprot.writeMessageEnd()
2208 
    self._oprot.trans.flush()
2209 
 
2210 
  def recv_addTag(self, ):
2211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2212 
    if mtype == TMessageType.EXCEPTION:
2213 
      x = TApplicationException()
2214 
      x.read(self._iprot)
2215 
      self._iprot.readMessageEnd()
2216 
      raise x
2217 
    result = addTag_result()
2218 
    result.read(self._iprot)
2219 
    self._iprot.readMessageEnd()
2220 
    if result.success is not None:
2221 
      return result.success
2222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2223 
 
2224 
  def deleteEntityTag(self, displayName, itemId):
2225 
    """
2226 
    Parameters:
2227 
     - displayName
2228 
     - itemId
2229 
    """
2230 
    self.send_deleteEntityTag(displayName, itemId)
2231 
    return self.recv_deleteEntityTag()
2232 
 
2233 
  def send_deleteEntityTag(self, displayName, itemId):
2234 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2235 
    args = deleteEntityTag_args()
2236 
    args.displayName = displayName
2237 
    args.itemId = itemId
2238 
    args.write(self._oprot)
2239 
    self._oprot.writeMessageEnd()
2240 
    self._oprot.trans.flush()
2241 
 
2242 
  def recv_deleteEntityTag(self, ):
2243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2244 
    if mtype == TMessageType.EXCEPTION:
2245 
      x = TApplicationException()
2246 
      x.read(self._iprot)
2247 
      self._iprot.readMessageEnd()
2248 
      raise x
2249 
    result = deleteEntityTag_result()
2250 
    result.read(self._iprot)
2251 
    self._iprot.readMessageEnd()
2252 
    if result.success is not None:
2253 
      return result.success
2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2255 
 
2256 
  def deleteTag(self, displayName):
2257 
    """
2258 
    Parameters:
2259 
     - displayName
2260 
    """
2261 
    self.send_deleteTag(displayName)
2262 
    return self.recv_deleteTag()
2263 
 
2264 
  def send_deleteTag(self, displayName):
2265 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2266 
    args = deleteTag_args()
2267 
    args.displayName = displayName
2268 
    args.write(self._oprot)
2269 
    self._oprot.writeMessageEnd()
2270 
    self._oprot.trans.flush()
2271 
 
2272 
  def recv_deleteTag(self, ):
2273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2274 
    if mtype == TMessageType.EXCEPTION:
2275 
      x = TApplicationException()
2276 
      x.read(self._iprot)
2277 
      self._iprot.readMessageEnd()
2278 
      raise x
2279 
    result = deleteTag_result()
2280 
    result.read(self._iprot)
2281 
    self._iprot.readMessageEnd()
2282 
    if result.success is not None:
2283 
      return result.success
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2285 
 
2286 
  def getAllTags(self, ):
2287 
    self.send_getAllTags()
2288 
    return self.recv_getAllTags()
2289 
 
2290 
  def send_getAllTags(self, ):
2291 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2292 
    args = getAllTags_args()
2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
2297 
  def recv_getAllTags(self, ):
2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
2304 
    result = getAllTags_result()
2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
2307 
    if result.success is not None:
2308 
      return result.success
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2310 
 
2311 
  def getAllEntitiesByTagName(self, displayName):
2312 
    """
2313 
    Parameters:
2314 
     - displayName
2315 
    """
2316 
    self.send_getAllEntitiesByTagName(displayName)
2317 
    return self.recv_getAllEntitiesByTagName()
2318 
 
2319 
  def send_getAllEntitiesByTagName(self, displayName):
2320 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2321 
    args = getAllEntitiesByTagName_args()
2322 
    args.displayName = displayName
2323 
    args.write(self._oprot)
2324 
    self._oprot.writeMessageEnd()
2325 
    self._oprot.trans.flush()
2326 
 
2327 
  def recv_getAllEntitiesByTagName(self, ):
2328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2329 
    if mtype == TMessageType.EXCEPTION:
2330 
      x = TApplicationException()
2331 
      x.read(self._iprot)
2332 
      self._iprot.readMessageEnd()
2333 
      raise x
2334 
    result = getAllEntitiesByTagName_result()
2335 
    result.read(self._iprot)
2336 
    self._iprot.readMessageEnd()
2337 
    if result.success is not None:
2338 
      return result.success
2339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2340 
 
6845 amit.gupta 2341 
  def getAllEntityTags(self, ):
2342 
    self.send_getAllEntityTags()
2343 
    return self.recv_getAllEntityTags()
2344 
 
2345 
  def send_getAllEntityTags(self, ):
2346 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2347 
    args = getAllEntityTags_args()
2348 
    args.write(self._oprot)
2349 
    self._oprot.writeMessageEnd()
2350 
    self._oprot.trans.flush()
2351 
 
2352 
  def recv_getAllEntityTags(self, ):
2353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2354 
    if mtype == TMessageType.EXCEPTION:
2355 
      x = TApplicationException()
2356 
      x.read(self._iprot)
2357 
      self._iprot.readMessageEnd()
2358 
      raise x
2359 
    result = getAllEntityTags_result()
2360 
    result.read(self._iprot)
2361 
    self._iprot.readMessageEnd()
2362 
    if result.success is not None:
2363 
      return result.success
2364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2365 
 
8590 kshitij.so 2366 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2367 
    """
8579 kshitij.so 2368 
    Banner Related
2369 
 
6850 kshitij.so 2370 
    Parameters:
8590 kshitij.so 2371 
     - bannerCongregate
6850 kshitij.so 2372 
    """
8590 kshitij.so 2373 
    self.send_addBanner(bannerCongregate)
2374 
    self.recv_addBanner()
6850 kshitij.so 2375 
 
8590 kshitij.so 2376 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2377 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2378 
    args = addBanner_args()
8590 kshitij.so 2379 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2380 
    args.write(self._oprot)
2381 
    self._oprot.writeMessageEnd()
2382 
    self._oprot.trans.flush()
2383 
 
2384 
  def recv_addBanner(self, ):
2385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2386 
    if mtype == TMessageType.EXCEPTION:
2387 
      x = TApplicationException()
2388 
      x.read(self._iprot)
2389 
      self._iprot.readMessageEnd()
2390 
      raise x
2391 
    result = addBanner_result()
2392 
    result.read(self._iprot)
2393 
    self._iprot.readMessageEnd()
8590 kshitij.so 2394 
    return
6850 kshitij.so 2395 
 
8579 kshitij.so 2396 
  def updateBanner(self, banner):
2397 
    """
2398 
    Parameters:
2399 
     - banner
2400 
    """
2401 
    self.send_updateBanner(banner)
2402 
    return self.recv_updateBanner()
2403 
 
2404 
  def send_updateBanner(self, banner):
2405 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2406 
    args = updateBanner_args()
2407 
    args.banner = banner
2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_updateBanner(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = updateBanner_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
2422 
    if result.success is not None:
2423 
      return result.success
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2425 
 
6850 kshitij.so 2426 
  def getAllBanners(self, ):
2427 
    self.send_getAllBanners()
2428 
    return self.recv_getAllBanners()
2429 
 
2430 
  def send_getAllBanners(self, ):
2431 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2432 
    args = getAllBanners_args()
2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
2437 
  def recv_getAllBanners(self, ):
2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
2444 
    result = getAllBanners_result()
2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
2447 
    if result.success is not None:
2448 
      return result.success
2449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2450 
 
9155 kshitij.so 2451 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2452 
    """
2453 
    Parameters:
2454 
     - bannerName
9155 kshitij.so 2455 
     - bannerType
6850 kshitij.so 2456 
    """
9155 kshitij.so 2457 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2458 
    return self.recv_deleteBanner()
2459 
 
9155 kshitij.so 2460 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2461 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2462 
    args = deleteBanner_args()
2463 
    args.bannerName = bannerName
9155 kshitij.so 2464 
    args.bannerType = bannerType
6850 kshitij.so 2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
2469 
  def recv_deleteBanner(self, ):
2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
2476 
    result = deleteBanner_result()
2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
2479 
    if result.success is not None:
2480 
      return result.success
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2482 
 
9155 kshitij.so 2483 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2484 
    """
2485 
    Parameters:
2486 
     - bannerName
9155 kshitij.so 2487 
     - bannerType
6850 kshitij.so 2488 
    """
9155 kshitij.so 2489 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2490 
    return self.recv_getBannerDetails()
2491 
 
9155 kshitij.so 2492 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2493 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2494 
    args = getBannerDetails_args()
2495 
    args.bannerName = bannerName
9155 kshitij.so 2496 
    args.bannerType = bannerType
6850 kshitij.so 2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_getBannerDetails(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = getBannerDetails_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
2511 
    if result.success is not None:
2512 
      return result.success
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2514 
 
2515 
  def getActiveBanners(self, ):
2516 
    self.send_getActiveBanners()
2517 
    return self.recv_getActiveBanners()
2518 
 
2519 
  def send_getActiveBanners(self, ):
2520 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2521 
    args = getActiveBanners_args()
2522 
    args.write(self._oprot)
2523 
    self._oprot.writeMessageEnd()
2524 
    self._oprot.trans.flush()
2525 
 
2526 
  def recv_getActiveBanners(self, ):
2527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2528 
    if mtype == TMessageType.EXCEPTION:
2529 
      x = TApplicationException()
2530 
      x.read(self._iprot)
2531 
      self._iprot.readMessageEnd()
2532 
      raise x
2533 
    result = getActiveBanners_result()
2534 
    result.read(self._iprot)
2535 
    self._iprot.readMessageEnd()
2536 
    if result.success is not None:
2537 
      return result.success
2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2539 
 
8579 kshitij.so 2540 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2541 
    """
2542 
    Parameters:
8579 kshitij.so 2543 
     - bannerMaps
6849 kshitij.so 2544 
    """
8579 kshitij.so 2545 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2546 
    return self.recv_addBannerMap()
2547 
 
8579 kshitij.so 2548 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2549 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2550 
    args = addBannerMap_args()
8579 kshitij.so 2551 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2556 
  def recv_addBannerMap(self, ):
2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2563 
    result = addBannerMap_result()
2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
2566 
    if result.success is not None:
2567 
      return result.success
2568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2569 
 
8579 kshitij.so 2570 
  def updateBannerMap(self, bannerMap):
2571 
    """
2572 
    Parameters:
2573 
     - bannerMap
2574 
    """
2575 
    self.send_updateBannerMap(bannerMap)
2576 
    return self.recv_updateBannerMap()
2577 
 
2578 
  def send_updateBannerMap(self, bannerMap):
2579 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2580 
    args = updateBannerMap_args()
2581 
    args.bannerMap = bannerMap
2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
2586 
  def recv_updateBannerMap(self, ):
2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
2593 
    result = updateBannerMap_result()
2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
2596 
    if result.success is not None:
2597 
      return result.success
2598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2599 
 
6849 kshitij.so 2600 
  def deleteBannerMap(self, bannerName):
2601 
    """
2602 
    Parameters:
2603 
     - bannerName
2604 
    """
2605 
    self.send_deleteBannerMap(bannerName)
2606 
    return self.recv_deleteBannerMap()
2607 
 
2608 
  def send_deleteBannerMap(self, bannerName):
2609 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2610 
    args = deleteBannerMap_args()
2611 
    args.bannerName = bannerName
2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
2616 
  def recv_deleteBannerMap(self, ):
2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
2623 
    result = deleteBannerMap_result()
2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
2626 
    if result.success is not None:
2627 
      return result.success
2628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2629 
 
9155 kshitij.so 2630 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2631 
    """
2632 
    Parameters:
2633 
     - bannerName
9155 kshitij.so 2634 
     - bannerType
6849 kshitij.so 2635 
    """
9155 kshitij.so 2636 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2637 
    return self.recv_getBannerMapDetails()
2638 
 
9155 kshitij.so 2639 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2640 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2641 
    args = getBannerMapDetails_args()
2642 
    args.bannerName = bannerName
9155 kshitij.so 2643 
    args.bannerType = bannerType
6849 kshitij.so 2644 
    args.write(self._oprot)
2645 
    self._oprot.writeMessageEnd()
2646 
    self._oprot.trans.flush()
2647 
 
2648 
  def recv_getBannerMapDetails(self, ):
2649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2650 
    if mtype == TMessageType.EXCEPTION:
2651 
      x = TApplicationException()
2652 
      x.read(self._iprot)
2653 
      self._iprot.readMessageEnd()
2654 
      raise x
2655 
    result = getBannerMapDetails_result()
2656 
    result.read(self._iprot)
2657 
    self._iprot.readMessageEnd()
2658 
    if result.success is not None:
2659 
      return result.success
2660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2661 
 
8579 kshitij.so 2662 
  def addBannerUri(self, bannerUriMappings):
2663 
    """
2664 
    Parameters:
2665 
     - bannerUriMappings
2666 
    """
2667 
    self.send_addBannerUri(bannerUriMappings)
2668 
    self.recv_addBannerUri()
2669 
 
2670 
  def send_addBannerUri(self, bannerUriMappings):
2671 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2672 
    args = addBannerUri_args()
2673 
    args.bannerUriMappings = bannerUriMappings
2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2678 
  def recv_addBannerUri(self, ):
2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2685 
    result = addBannerUri_result()
2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
2688 
    return
2689 
 
9155 kshitij.so 2690 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2691 
    """
2692 
    Parameters:
2693 
     - bannerName
9155 kshitij.so 2694 
     - bannerType
8579 kshitij.so 2695 
    """
9155 kshitij.so 2696 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2697 
    return self.recv_getUriMapping()
2698 
 
9155 kshitij.so 2699 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2700 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2701 
    args = getUriMapping_args()
2702 
    args.bannerName = bannerName
9155 kshitij.so 2703 
    args.bannerType = bannerType
8579 kshitij.so 2704 
    args.write(self._oprot)
2705 
    self._oprot.writeMessageEnd()
2706 
    self._oprot.trans.flush()
2707 
 
2708 
  def recv_getUriMapping(self, ):
2709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2710 
    if mtype == TMessageType.EXCEPTION:
2711 
      x = TApplicationException()
2712 
      x.read(self._iprot)
2713 
      self._iprot.readMessageEnd()
2714 
      raise x
2715 
    result = getUriMapping_result()
2716 
    result.read(self._iprot)
2717 
    self._iprot.readMessageEnd()
2718 
    if result.success is not None:
2719 
      return result.success
2720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2721 
 
2722 
  def addCampaign(self, campaign):
2723 
    """
2724 
    Parameters:
2725 
     - campaign
2726 
    """
2727 
    self.send_addCampaign(campaign)
2728 
    self.recv_addCampaign()
2729 
 
2730 
  def send_addCampaign(self, campaign):
2731 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2732 
    args = addCampaign_args()
2733 
    args.campaign = campaign
2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2738 
  def recv_addCampaign(self, ):
2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2745 
    result = addCampaign_result()
2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
2748 
    return
2749 
 
2750 
  def getCampaigns(self, campaignName):
2751 
    """
2752 
    Parameters:
2753 
     - campaignName
2754 
    """
2755 
    self.send_getCampaigns(campaignName)
2756 
    return self.recv_getCampaigns()
2757 
 
2758 
  def send_getCampaigns(self, campaignName):
2759 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2760 
    args = getCampaigns_args()
2761 
    args.campaignName = campaignName
2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
2766 
  def recv_getCampaigns(self, ):
2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
2773 
    result = getCampaigns_result()
2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
2776 
    if result.success is not None:
2777 
      return result.success
2778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2779 
 
2780 
  def deleteCampaign(self, campaignId):
2781 
    """
2782 
    Parameters:
2783 
     - campaignId
2784 
    """
2785 
    self.send_deleteCampaign(campaignId)
2786 
    self.recv_deleteCampaign()
2787 
 
2788 
  def send_deleteCampaign(self, campaignId):
2789 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2790 
    args = deleteCampaign_args()
2791 
    args.campaignId = campaignId
2792 
    args.write(self._oprot)
2793 
    self._oprot.writeMessageEnd()
2794 
    self._oprot.trans.flush()
2795 
 
2796 
  def recv_deleteCampaign(self, ):
2797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2798 
    if mtype == TMessageType.EXCEPTION:
2799 
      x = TApplicationException()
2800 
      x.read(self._iprot)
2801 
      self._iprot.readMessageEnd()
2802 
      raise x
2803 
    result = deleteCampaign_result()
2804 
    result.read(self._iprot)
2805 
    self._iprot.readMessageEnd()
2806 
    return
2807 
 
2808 
  def getAllCampaigns(self, ):
2809 
    self.send_getAllCampaigns()
2810 
    return self.recv_getAllCampaigns()
2811 
 
2812 
  def send_getAllCampaigns(self, ):
2813 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2814 
    args = getAllCampaigns_args()
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_getAllCampaigns(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = getAllCampaigns_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
2829 
    if result.success is not None:
2830 
      return result.success
2831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2832 
 
9155 kshitij.so 2833 
  def getActiveBannersForMobileSite(self, ):
2834 
    self.send_getActiveBannersForMobileSite()
2835 
    return self.recv_getActiveBannersForMobileSite()
2836 
 
2837 
  def send_getActiveBannersForMobileSite(self, ):
2838 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2839 
    args = getActiveBannersForMobileSite_args()
2840 
    args.write(self._oprot)
2841 
    self._oprot.writeMessageEnd()
2842 
    self._oprot.trans.flush()
2843 
 
2844 
  def recv_getActiveBannersForMobileSite(self, ):
2845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2846 
    if mtype == TMessageType.EXCEPTION:
2847 
      x = TApplicationException()
2848 
      x.read(self._iprot)
2849 
      self._iprot.readMessageEnd()
2850 
      raise x
2851 
    result = getActiveBannersForMobileSite_result()
2852 
    result.read(self._iprot)
2853 
    self._iprot.readMessageEnd()
2854 
    if result.success is not None:
2855 
      return result.success
2856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2857 
 
5944 mandeep.dh 2858 
  def deleteSimilarItem(self, itemId, catalogItemId):
2859 
    """
2860 
    Delete similar item.
2861 
 
2862 
    Parameters:
2863 
     - itemId
2864 
     - catalogItemId
2865 
    """
2866 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2867 
    return self.recv_deleteSimilarItem()
2868 
 
2869 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2870 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2871 
    args = deleteSimilarItem_args()
2872 
    args.itemId = itemId
2873 
    args.catalogItemId = catalogItemId
2874 
    args.write(self._oprot)
2875 
    self._oprot.writeMessageEnd()
2876 
    self._oprot.trans.flush()
2877 
 
2878 
  def recv_deleteSimilarItem(self, ):
2879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2880 
    if mtype == TMessageType.EXCEPTION:
2881 
      x = TApplicationException()
2882 
      x.read(self._iprot)
2883 
      self._iprot.readMessageEnd()
2884 
      raise x
2885 
    result = deleteSimilarItem_result()
2886 
    result.read(self._iprot)
2887 
    self._iprot.readMessageEnd()
2888 
    if result.success is not None:
2889 
      return result.success
2890 
    if result.cex is not None:
2891 
      raise result.cex
2892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2893 
 
2894 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2895 
    """
2896 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2897 
    If yes, returns the itemId else returns 0
2898 
 
2899 
    Parameters:
2900 
     - brand
2901 
     - modelNumber
2902 
     - modelName
2903 
     - color
2904 
    """
2905 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2906 
    return self.recv_checkSimilarItem()
2907 
 
2908 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2909 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2910 
    args = checkSimilarItem_args()
2911 
    args.brand = brand
2912 
    args.modelNumber = modelNumber
2913 
    args.modelName = modelName
2914 
    args.color = color
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_checkSimilarItem(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = checkSimilarItem_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
2929 
    if result.success is not None:
2930 
      return result.success
2931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2932 
 
2933 
  def validateRiskyStatus(self, itemId):
2934 
    """
2935 
    Check wether item is risky and change status if inventory is not available for risky items
2936 
 
2937 
    Parameters:
2938 
     - itemId
2939 
    """
2940 
    self.send_validateRiskyStatus(itemId)
2941 
    self.recv_validateRiskyStatus()
2942 
 
2943 
  def send_validateRiskyStatus(self, itemId):
2944 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2945 
    args = validateRiskyStatus_args()
2946 
    args.itemId = itemId
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_validateRiskyStatus(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = validateRiskyStatus_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
2961 
    return
2962 
 
2963 
  def changeItemRiskyFlag(self, itemId, risky):
2964 
    """
2965 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2966 
 
2967 
    Parameters:
2968 
     - itemId
2969 
     - risky
2970 
    """
2971 
    self.send_changeItemRiskyFlag(itemId, risky)
2972 
    self.recv_changeItemRiskyFlag()
2973 
 
2974 
  def send_changeItemRiskyFlag(self, itemId, risky):
2975 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2976 
    args = changeItemRiskyFlag_args()
2977 
    args.itemId = itemId
2978 
    args.risky = risky
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_changeItemRiskyFlag(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = changeItemRiskyFlag_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
2993 
    return
2994 
 
2995 
  def getItemsByRiskyFlag(self, ):
2996 
    """
2997 
    Returns list of items marked as risky.
2998 
    """
2999 
    self.send_getItemsByRiskyFlag()
3000 
    return self.recv_getItemsByRiskyFlag()
3001 
 
3002 
  def send_getItemsByRiskyFlag(self, ):
3003 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3004 
    args = getItemsByRiskyFlag_args()
3005 
    args.write(self._oprot)
3006 
    self._oprot.writeMessageEnd()
3007 
    self._oprot.trans.flush()
3008 
 
3009 
  def recv_getItemsByRiskyFlag(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 = getItemsByRiskyFlag_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, "getItemsByRiskyFlag failed: unknown result");
3022 
 
3023 
  def getItemsForMasterSheet(self, category, brand):
3024 
    """
3025 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3026 
 
3027 
    Parameters:
3028 
     - category
3029 
     - brand
3030 
    """
3031 
    self.send_getItemsForMasterSheet(category, brand)
3032 
    return self.recv_getItemsForMasterSheet()
3033 
 
3034 
  def send_getItemsForMasterSheet(self, category, brand):
3035 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3036 
    args = getItemsForMasterSheet_args()
3037 
    args.category = category
3038 
    args.brand = brand
3039 
    args.write(self._oprot)
3040 
    self._oprot.writeMessageEnd()
3041 
    self._oprot.trans.flush()
3042 
 
3043 
  def recv_getItemsForMasterSheet(self, ):
3044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3045 
    if mtype == TMessageType.EXCEPTION:
3046 
      x = TApplicationException()
3047 
      x.read(self._iprot)
3048 
      self._iprot.readMessageEnd()
3049 
      raise x
3050 
    result = getItemsForMasterSheet_result()
3051 
    result.read(self._iprot)
3052 
    self._iprot.readMessageEnd()
3053 
    if result.success is not None:
3054 
      return result.success
3055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3056 
 
3057 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3058 
    """
3059 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3060 
 
3061 
    Parameters:
3062 
     - beginIndex
3063 
     - totalItems
3064 
     - itemId
3065 
    """
3066 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3067 
    return self.recv_getSimilarItemsCatalogIds()
3068 
 
3069 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3070 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3071 
    args = getSimilarItemsCatalogIds_args()
3072 
    args.beginIndex = beginIndex
3073 
    args.totalItems = totalItems
3074 
    args.itemId = itemId
3075 
    args.write(self._oprot)
3076 
    self._oprot.writeMessageEnd()
3077 
    self._oprot.trans.flush()
3078 
 
3079 
  def recv_getSimilarItemsCatalogIds(self, ):
3080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3081 
    if mtype == TMessageType.EXCEPTION:
3082 
      x = TApplicationException()
3083 
      x.read(self._iprot)
3084 
      self._iprot.readMessageEnd()
3085 
      raise x
3086 
    result = getSimilarItemsCatalogIds_result()
3087 
    result.read(self._iprot)
3088 
    self._iprot.readMessageEnd()
3089 
    if result.success is not None:
3090 
      return result.success
3091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3092 
 
3093 
  def addProductNotification(self, itemId, email):
3094 
    """
3095 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3096 
 
3097 
    Parameters:
3098 
     - itemId
3099 
     - email
3100 
    """
3101 
    self.send_addProductNotification(itemId, email)
3102 
    return self.recv_addProductNotification()
3103 
 
3104 
  def send_addProductNotification(self, itemId, email):
3105 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3106 
    args = addProductNotification_args()
3107 
    args.itemId = itemId
3108 
    args.email = email
3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3113 
  def recv_addProductNotification(self, ):
3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3120 
    result = addProductNotification_result()
3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
3123 
    if result.success is not None:
3124 
      return result.success
3125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3126 
 
3127 
  def sendProductNotifications(self, ):
3128 
    """
3129 
    Send the product notifications to the users for items which has stock.
3130 
    """
3131 
    self.send_sendProductNotifications()
3132 
    return self.recv_sendProductNotifications()
3133 
 
3134 
  def send_sendProductNotifications(self, ):
3135 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3136 
    args = sendProductNotifications_args()
3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_sendProductNotifications(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = sendProductNotifications_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3151 
    if result.success is not None:
3152 
      return result.success
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3154 
 
3155 
  def getAllBrandsByCategory(self, categoryId):
3156 
    """
3157 
    Returns list of brand names for a given category Id
3158 
 
3159 
    Parameters:
3160 
     - categoryId
3161 
    """
3162 
    self.send_getAllBrandsByCategory(categoryId)
3163 
    return self.recv_getAllBrandsByCategory()
3164 
 
3165 
  def send_getAllBrandsByCategory(self, categoryId):
3166 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3167 
    args = getAllBrandsByCategory_args()
3168 
    args.categoryId = categoryId
3169 
    args.write(self._oprot)
3170 
    self._oprot.writeMessageEnd()
3171 
    self._oprot.trans.flush()
3172 
 
3173 
  def recv_getAllBrandsByCategory(self, ):
3174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3175 
    if mtype == TMessageType.EXCEPTION:
3176 
      x = TApplicationException()
3177 
      x.read(self._iprot)
3178 
      self._iprot.readMessageEnd()
3179 
      raise x
3180 
    result = getAllBrandsByCategory_result()
3181 
    result.read(self._iprot)
3182 
    self._iprot.readMessageEnd()
3183 
    if result.success is not None:
3184 
      return result.success
3185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3186 
 
3187 
  def getAllBrands(self, ):
3188 
    """
3189 
    Returns list of brand names
3190 
    """
3191 
    self.send_getAllBrands()
3192 
    return self.recv_getAllBrands()
3193 
 
3194 
  def send_getAllBrands(self, ):
3195 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3196 
    args = getAllBrands_args()
3197 
    args.write(self._oprot)
3198 
    self._oprot.writeMessageEnd()
3199 
    self._oprot.trans.flush()
3200 
 
3201 
  def recv_getAllBrands(self, ):
3202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3203 
    if mtype == TMessageType.EXCEPTION:
3204 
      x = TApplicationException()
3205 
      x.read(self._iprot)
3206 
      self._iprot.readMessageEnd()
3207 
      raise x
3208 
    result = getAllBrands_result()
3209 
    result.read(self._iprot)
3210 
    self._iprot.readMessageEnd()
3211 
    if result.success is not None:
3212 
      return result.success
3213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3214 
 
3215 
  def getAllSources(self, ):
3216 
    """
3217 
    Return list of all sources
3218 
    """
3219 
    self.send_getAllSources()
3220 
    return self.recv_getAllSources()
3221 
 
3222 
  def send_getAllSources(self, ):
3223 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3224 
    args = getAllSources_args()
3225 
    args.write(self._oprot)
3226 
    self._oprot.writeMessageEnd()
3227 
    self._oprot.trans.flush()
3228 
 
3229 
  def recv_getAllSources(self, ):
3230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3231 
    if mtype == TMessageType.EXCEPTION:
3232 
      x = TApplicationException()
3233 
      x.read(self._iprot)
3234 
      self._iprot.readMessageEnd()
3235 
      raise x
3236 
    result = getAllSources_result()
3237 
    result.read(self._iprot)
3238 
    self._iprot.readMessageEnd()
3239 
    if result.success is not None:
3240 
      return result.success
3241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3242 
 
3243 
  def getItemPricingBySource(self, itemId, sourceId):
3244 
    """
3245 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3246 
 
3247 
    Parameters:
3248 
     - itemId
3249 
     - sourceId
3250 
    """
3251 
    self.send_getItemPricingBySource(itemId, sourceId)
3252 
    return self.recv_getItemPricingBySource()
3253 
 
3254 
  def send_getItemPricingBySource(self, itemId, sourceId):
3255 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3256 
    args = getItemPricingBySource_args()
3257 
    args.itemId = itemId
3258 
    args.sourceId = sourceId
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_getItemPricingBySource(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = getItemPricingBySource_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.cex is not None:
3276 
      raise result.cex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3278 
 
3279 
  def addSourceItemPricing(self, sourceItemPricing):
3280 
    """
3281 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3282 
    If item is not found or source is not found, it will throw exception.
3283 
 
3284 
    Parameters:
3285 
     - sourceItemPricing
3286 
    """
3287 
    self.send_addSourceItemPricing(sourceItemPricing)
3288 
    self.recv_addSourceItemPricing()
3289 
 
3290 
  def send_addSourceItemPricing(self, sourceItemPricing):
3291 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3292 
    args = addSourceItemPricing_args()
3293 
    args.sourceItemPricing = sourceItemPricing
3294 
    args.write(self._oprot)
3295 
    self._oprot.writeMessageEnd()
3296 
    self._oprot.trans.flush()
3297 
 
3298 
  def recv_addSourceItemPricing(self, ):
3299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3300 
    if mtype == TMessageType.EXCEPTION:
3301 
      x = TApplicationException()
3302 
      x.read(self._iprot)
3303 
      self._iprot.readMessageEnd()
3304 
      raise x
3305 
    result = addSourceItemPricing_result()
3306 
    result.read(self._iprot)
3307 
    self._iprot.readMessageEnd()
3308 
    if result.cex is not None:
3309 
      raise result.cex
3310 
    return
3311 
 
3312 
  def getAllSourcePricing(self, itemId):
3313 
    """
3314 
    Returns the list of source pricing information of an item.
3315 
    Raises an exception if item not found corresponding to itemId
3316 
 
3317 
    Parameters:
3318 
     - itemId
3319 
    """
3320 
    self.send_getAllSourcePricing(itemId)
3321 
    return self.recv_getAllSourcePricing()
3322 
 
3323 
  def send_getAllSourcePricing(self, itemId):
3324 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3325 
    args = getAllSourcePricing_args()
3326 
    args.itemId = itemId
3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_getAllSourcePricing(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = getAllSourcePricing_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
3341 
    if result.success is not None:
3342 
      return result.success
3343 
    if result.cex is not None:
3344 
      raise result.cex
3345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3346 
 
3347 
  def getItemForSource(self, item_id, sourceId):
3348 
    """
3349 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3350 
 
3351 
    Parameters:
3352 
     - item_id
3353 
     - sourceId
3354 
    """
3355 
    self.send_getItemForSource(item_id, sourceId)
3356 
    return self.recv_getItemForSource()
3357 
 
3358 
  def send_getItemForSource(self, item_id, sourceId):
3359 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3360 
    args = getItemForSource_args()
3361 
    args.item_id = item_id
3362 
    args.sourceId = sourceId
3363 
    args.write(self._oprot)
3364 
    self._oprot.writeMessageEnd()
3365 
    self._oprot.trans.flush()
3366 
 
3367 
  def recv_getItemForSource(self, ):
3368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3369 
    if mtype == TMessageType.EXCEPTION:
3370 
      x = TApplicationException()
3371 
      x.read(self._iprot)
3372 
      self._iprot.readMessageEnd()
3373 
      raise x
3374 
    result = getItemForSource_result()
3375 
    result.read(self._iprot)
3376 
    self._iprot.readMessageEnd()
3377 
    if result.success is not None:
3378 
      return result.success
3379 
    if result.cex is not None:
3380 
      raise result.cex
3381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3382 
 
3383 
  def searchItemsInRange(self, searchTerms, offset, limit):
3384 
    """
3385 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3386 
 
3387 
    Parameters:
3388 
     - searchTerms
3389 
     - offset
3390 
     - limit
3391 
    """
3392 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3393 
    return self.recv_searchItemsInRange()
3394 
 
3395 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3396 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3397 
    args = searchItemsInRange_args()
3398 
    args.searchTerms = searchTerms
3399 
    args.offset = offset
3400 
    args.limit = limit
3401 
    args.write(self._oprot)
3402 
    self._oprot.writeMessageEnd()
3403 
    self._oprot.trans.flush()
3404 
 
3405 
  def recv_searchItemsInRange(self, ):
3406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3407 
    if mtype == TMessageType.EXCEPTION:
3408 
      x = TApplicationException()
3409 
      x.read(self._iprot)
3410 
      self._iprot.readMessageEnd()
3411 
      raise x
3412 
    result = searchItemsInRange_result()
3413 
    result.read(self._iprot)
3414 
    self._iprot.readMessageEnd()
3415 
    if result.success is not None:
3416 
      return result.success
3417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3418 
 
3419 
  def getSearchResultCount(self, searchTerms):
3420 
    """
3421 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3422 
 
3423 
    Parameters:
3424 
     - searchTerms
3425 
    """
3426 
    self.send_getSearchResultCount(searchTerms)
3427 
    return self.recv_getSearchResultCount()
3428 
 
3429 
  def send_getSearchResultCount(self, searchTerms):
3430 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3431 
    args = getSearchResultCount_args()
3432 
    args.searchTerms = searchTerms
3433 
    args.write(self._oprot)
3434 
    self._oprot.writeMessageEnd()
3435 
    self._oprot.trans.flush()
3436 
 
3437 
  def recv_getSearchResultCount(self, ):
3438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3439 
    if mtype == TMessageType.EXCEPTION:
3440 
      x = TApplicationException()
3441 
      x.read(self._iprot)
3442 
      self._iprot.readMessageEnd()
3443 
      raise x
3444 
    result = getSearchResultCount_result()
3445 
    result.read(self._iprot)
3446 
    self._iprot.readMessageEnd()
3447 
    if result.success is not None:
3448 
      return result.success
3449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3450 
 
3451 
  def getProductNotifications(self, startDateTime):
3452 
    """
3453 
    Returns a list of product notifications added after a supplied datetime
3454 
 
3455 
    Parameters:
3456 
     - startDateTime
3457 
    """
3458 
    self.send_getProductNotifications(startDateTime)
3459 
    return self.recv_getProductNotifications()
3460 
 
3461 
  def send_getProductNotifications(self, startDateTime):
3462 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3463 
    args = getProductNotifications_args()
3464 
    args.startDateTime = startDateTime
3465 
    args.write(self._oprot)
3466 
    self._oprot.writeMessageEnd()
3467 
    self._oprot.trans.flush()
3468 
 
3469 
  def recv_getProductNotifications(self, ):
3470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3471 
    if mtype == TMessageType.EXCEPTION:
3472 
      x = TApplicationException()
3473 
      x.read(self._iprot)
3474 
      self._iprot.readMessageEnd()
3475 
      raise x
3476 
    result = getProductNotifications_result()
3477 
    result.read(self._iprot)
3478 
    self._iprot.readMessageEnd()
3479 
    if result.success is not None:
3480 
      return result.success
3481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3482 
 
7897 amar.kumar 3483 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3484 
    """
3485 
    Returns a list of count of requests for product notification against each item
3486 
 
3487 
    Parameters:
3488 
     - startDateTime
7897 amar.kumar 3489 
     - categoryId
5944 mandeep.dh 3490 
    """
7897 amar.kumar 3491 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3492 
    return self.recv_getProductNotificationRequestCount()
3493 
 
7897 amar.kumar 3494 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3495 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3496 
    args = getProductNotificationRequestCount_args()
3497 
    args.startDateTime = startDateTime
7897 amar.kumar 3498 
    args.categoryId = categoryId
5944 mandeep.dh 3499 
    args.write(self._oprot)
3500 
    self._oprot.writeMessageEnd()
3501 
    self._oprot.trans.flush()
3502 
 
3503 
  def recv_getProductNotificationRequestCount(self, ):
3504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3505 
    if mtype == TMessageType.EXCEPTION:
3506 
      x = TApplicationException()
3507 
      x.read(self._iprot)
3508 
      self._iprot.readMessageEnd()
3509 
      raise x
3510 
    result = getProductNotificationRequestCount_result()
3511 
    result.read(self._iprot)
3512 
    self._iprot.readMessageEnd()
3513 
    if result.success is not None:
3514 
      return result.success
3515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3516 
 
3517 
  def addAuthorizationLog(self, itemId, username, reason):
3518 
    """
3519 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3520 
 
3521 
    Parameters:
3522 
     - itemId
3523 
     - username
3524 
     - reason
3525 
    """
3526 
    self.send_addAuthorizationLog(itemId, username, reason)
3527 
    return self.recv_addAuthorizationLog()
3528 
 
3529 
  def send_addAuthorizationLog(self, itemId, username, reason):
3530 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3531 
    args = addAuthorizationLog_args()
3532 
    args.itemId = itemId
3533 
    args.username = username
3534 
    args.reason = reason
3535 
    args.write(self._oprot)
3536 
    self._oprot.writeMessageEnd()
3537 
    self._oprot.trans.flush()
3538 
 
3539 
  def recv_addAuthorizationLog(self, ):
3540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3541 
    if mtype == TMessageType.EXCEPTION:
3542 
      x = TApplicationException()
3543 
      x.read(self._iprot)
3544 
      self._iprot.readMessageEnd()
3545 
      raise x
3546 
    result = addAuthorizationLog_result()
3547 
    result.read(self._iprot)
3548 
    self._iprot.readMessageEnd()
3549 
    if result.success is not None:
3550 
      return result.success
3551 
    if result.cex is not None:
3552 
      raise result.cex
3553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3554 
 
3555 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3556 
    """
3557 
    Parameters:
3558 
     - catalog_item_id
3559 
     - voucherType
3560 
     - voucherAmount
3561 
    """
3562 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3563 
    return self.recv_addupdateVoucherForItem()
3564 
 
3565 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3566 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3567 
    args = addupdateVoucherForItem_args()
3568 
    args.catalog_item_id = catalog_item_id
3569 
    args.voucherType = voucherType
3570 
    args.voucherAmount = voucherAmount
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_addupdateVoucherForItem(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = addupdateVoucherForItem_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3585 
    if result.success is not None:
3586 
      return result.success
3587 
    if result.cex is not None:
3588 
      raise result.cex
3589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3590 
 
3591 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3592 
    """
3593 
    Parameters:
3594 
     - catalog_item_id
3595 
     - voucherType
3596 
    """
3597 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3598 
    return self.recv_deleteVoucherForItem()
3599 
 
3600 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3601 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3602 
    args = deleteVoucherForItem_args()
3603 
    args.catalog_item_id = catalog_item_id
3604 
    args.voucherType = voucherType
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_deleteVoucherForItem(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = deleteVoucherForItem_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    if result.cex is not None:
3622 
      raise result.cex
3623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3624 
 
3625 
  def getVoucherAmount(self, itemId, voucherType):
3626 
    """
3627 
    Parameters:
3628 
     - itemId
3629 
     - voucherType
3630 
    """
3631 
    self.send_getVoucherAmount(itemId, voucherType)
3632 
    return self.recv_getVoucherAmount()
3633 
 
3634 
  def send_getVoucherAmount(self, itemId, voucherType):
3635 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3636 
    args = getVoucherAmount_args()
3637 
    args.itemId = itemId
3638 
    args.voucherType = voucherType
3639 
    args.write(self._oprot)
3640 
    self._oprot.writeMessageEnd()
3641 
    self._oprot.trans.flush()
3642 
 
3643 
  def recv_getVoucherAmount(self, ):
3644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3645 
    if mtype == TMessageType.EXCEPTION:
3646 
      x = TApplicationException()
3647 
      x.read(self._iprot)
3648 
      self._iprot.readMessageEnd()
3649 
      raise x
3650 
    result = getVoucherAmount_result()
3651 
    result.read(self._iprot)
3652 
    self._iprot.readMessageEnd()
3653 
    if result.success is not None:
3654 
      return result.success
3655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3656 
 
3657 
  def getAllItemVouchers(self, itemId):
3658 
    """
3659 
    Parameters:
3660 
     - itemId
3661 
    """
3662 
    self.send_getAllItemVouchers(itemId)
3663 
    return self.recv_getAllItemVouchers()
3664 
 
3665 
  def send_getAllItemVouchers(self, itemId):
3666 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3667 
    args = getAllItemVouchers_args()
3668 
    args.itemId = itemId
3669 
    args.write(self._oprot)
3670 
    self._oprot.writeMessageEnd()
3671 
    self._oprot.trans.flush()
3672 
 
3673 
  def recv_getAllItemVouchers(self, ):
3674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3675 
    if mtype == TMessageType.EXCEPTION:
3676 
      x = TApplicationException()
3677 
      x.read(self._iprot)
3678 
      self._iprot.readMessageEnd()
3679 
      raise x
3680 
    result = getAllItemVouchers_result()
3681 
    result.read(self._iprot)
3682 
    self._iprot.readMessageEnd()
3683 
    if result.success is not None:
3684 
      return result.success
3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3686 
 
3687 
  def isValidCatalogItemId(self, catalog_item_id):
3688 
    """
3689 
    Parameters:
3690 
     - catalog_item_id
3691 
    """
3692 
    self.send_isValidCatalogItemId(catalog_item_id)
3693 
    return self.recv_isValidCatalogItemId()
3694 
 
3695 
  def send_isValidCatalogItemId(self, catalog_item_id):
3696 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3697 
    args = isValidCatalogItemId_args()
3698 
    args.catalog_item_id = catalog_item_id
3699 
    args.write(self._oprot)
3700 
    self._oprot.writeMessageEnd()
3701 
    self._oprot.trans.flush()
3702 
 
3703 
  def recv_isValidCatalogItemId(self, ):
3704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3705 
    if mtype == TMessageType.EXCEPTION:
3706 
      x = TApplicationException()
3707 
      x.read(self._iprot)
3708 
      self._iprot.readMessageEnd()
3709 
      raise x
3710 
    result = isValidCatalogItemId_result()
3711 
    result.read(self._iprot)
3712 
    self._iprot.readMessageEnd()
3713 
    if result.success is not None:
3714 
      return result.success
3715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3716 
 
7330 amit.gupta 3717 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3718 
    """
3719 
    Parameters:
3720 
     - itemId
7330 amit.gupta 3721 
     - stateId
6039 amit.gupta 3722 
     - price
3723 
    """
7330 amit.gupta 3724 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3725 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3726 
 
7330 amit.gupta 3727 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3728 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3729 
    args = getVatPercentageForItem_args()
3730 
    args.itemId = itemId
7330 amit.gupta 3731 
    args.stateId = stateId
6039 amit.gupta 3732 
    args.price = price
3733 
    args.write(self._oprot)
3734 
    self._oprot.writeMessageEnd()
3735 
    self._oprot.trans.flush()
3736 
 
3737 
  def recv_getVatPercentageForItem(self, ):
3738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3739 
    if mtype == TMessageType.EXCEPTION:
3740 
      x = TApplicationException()
3741 
      x.read(self._iprot)
3742 
      self._iprot.readMessageEnd()
3743 
      raise x
3744 
    result = getVatPercentageForItem_result()
3745 
    result.read(self._iprot)
3746 
    self._iprot.readMessageEnd()
3747 
    if result.success is not None:
3748 
      return result.success
7340 amit.gupta 3749 
    if result.cex is not None:
3750 
      raise result.cex
6039 amit.gupta 3751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3752 
 
3753 
  def getVatAmountForItem(self, itemId, price):
3754 
    """
3755 
    Parameters:
3756 
     - itemId
3757 
     - price
3758 
    """
3759 
    self.send_getVatAmountForItem(itemId, price)
3760 
    return self.recv_getVatAmountForItem()
3761 
 
3762 
  def send_getVatAmountForItem(self, itemId, price):
3763 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3764 
    args = getVatAmountForItem_args()
3765 
    args.itemId = itemId
3766 
    args.price = price
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_getVatAmountForItem(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = getVatAmountForItem_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
3781 
    if result.success is not None:
3782 
      return result.success
3783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3784 
 
6531 vikram.rag 3785 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3786 
    """
3787 
    Parameters:
3788 
     - offset
3789 
     - limit
3790 
    """
3791 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3792 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3793 
 
6531 vikram.rag 3794 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3795 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3796 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3797 
    args.offset = offset
3798 
    args.limit = limit
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.success is not None:
3814 
      return result.success
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3816 
 
6821 amar.kumar 3817 
  def getAllAliveItems(self, ):
3818 
    self.send_getAllAliveItems()
3819 
    return self.recv_getAllAliveItems()
3820 
 
3821 
  def send_getAllAliveItems(self, ):
3822 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3823 
    args = getAllAliveItems_args()
3824 
    args.write(self._oprot)
3825 
    self._oprot.writeMessageEnd()
3826 
    self._oprot.trans.flush()
3827 
 
3828 
  def recv_getAllAliveItems(self, ):
3829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3830 
    if mtype == TMessageType.EXCEPTION:
3831 
      x = TApplicationException()
3832 
      x.read(self._iprot)
3833 
      self._iprot.readMessageEnd()
3834 
      raise x
3835 
    result = getAllAliveItems_result()
3836 
    result.read(self._iprot)
3837 
    self._iprot.readMessageEnd()
3838 
    if result.success is not None:
3839 
      return result.success
3840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3841 
 
6921 anupam.sin 3842 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3843 
    """
3844 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3845 
 
6805 anupam.sin 3846 
    Parameters:
3847 
     - itemId
6921 anupam.sin 3848 
     - price
6805 anupam.sin 3849 
     - insurerId
3850 
     - quantity
3851 
    """
6921 anupam.sin 3852 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3853 
    return self.recv_getInsuranceAmount()
3854 
 
6921 anupam.sin 3855 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3856 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3857 
    args = getInsuranceAmount_args()
3858 
    args.itemId = itemId
6921 anupam.sin 3859 
    args.price = price
6805 anupam.sin 3860 
    args.insurerId = insurerId
3861 
    args.quantity = quantity
3862 
    args.write(self._oprot)
3863 
    self._oprot.writeMessageEnd()
3864 
    self._oprot.trans.flush()
3865 
 
3866 
  def recv_getInsuranceAmount(self, ):
3867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3868 
    if mtype == TMessageType.EXCEPTION:
3869 
      x = TApplicationException()
3870 
      x.read(self._iprot)
3871 
      self._iprot.readMessageEnd()
3872 
      raise x
3873 
    result = getInsuranceAmount_result()
3874 
    result.read(self._iprot)
3875 
    self._iprot.readMessageEnd()
3876 
    if result.success is not None:
3877 
      return result.success
3878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3879 
 
3880 
  def getInsurer(self, insurerId):
3881 
    """
3882 
    Parameters:
3883 
     - insurerId
3884 
    """
3885 
    self.send_getInsurer(insurerId)
3886 
    return self.recv_getInsurer()
3887 
 
3888 
  def send_getInsurer(self, insurerId):
3889 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3890 
    args = getInsurer_args()
3891 
    args.insurerId = insurerId
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_getInsurer(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = getInsurer_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3906 
    if result.success is not None:
3907 
      return result.success
3908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3909 
 
6838 vikram.rag 3910 
  def getAllInsurers(self, ):
3911 
    self.send_getAllInsurers()
3912 
    return self.recv_getAllInsurers()
6805 anupam.sin 3913 
 
6838 vikram.rag 3914 
  def send_getAllInsurers(self, ):
3915 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3916 
    args = getAllInsurers_args()
3917 
    args.write(self._oprot)
3918 
    self._oprot.writeMessageEnd()
3919 
    self._oprot.trans.flush()
3920 
 
3921 
  def recv_getAllInsurers(self, ):
3922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3923 
    if mtype == TMessageType.EXCEPTION:
3924 
      x = TApplicationException()
3925 
      x.read(self._iprot)
3926 
      self._iprot.readMessageEnd()
3927 
      raise x
3928 
    result = getAllInsurers_result()
3929 
    result.read(self._iprot)
3930 
    self._iprot.readMessageEnd()
3931 
    if result.success is not None:
3932 
      return result.success
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3934 
 
6962 rajveer 3935 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3936 
    """
3937 
    Parameters:
3938 
     - insurerId
3939 
     - amount
3940 
    """
3941 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3942 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3943 
 
6962 rajveer 3944 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3945 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3946 
    args = updateInsuranceDeclaredAmount_args()
3947 
    args.insurerId = insurerId
3948 
    args.amount = amount
3949 
    args.write(self._oprot)
3950 
    self._oprot.writeMessageEnd()
3951 
    self._oprot.trans.flush()
3952 
 
3953 
  def recv_updateInsuranceDeclaredAmount(self, ):
3954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3955 
    if mtype == TMessageType.EXCEPTION:
3956 
      x = TApplicationException()
3957 
      x.read(self._iprot)
3958 
      self._iprot.readMessageEnd()
3959 
      raise x
3960 
    result = updateInsuranceDeclaredAmount_result()
3961 
    result.read(self._iprot)
3962 
    self._iprot.readMessageEnd()
3963 
    return
3964 
 
7190 amar.kumar 3965 
  def getFreebieForItem(self, itemId):
3966 
    """
3967 
    Parameters:
3968 
     - itemId
3969 
    """
3970 
    self.send_getFreebieForItem(itemId)
3971 
    return self.recv_getFreebieForItem()
6962 rajveer 3972 
 
7190 amar.kumar 3973 
  def send_getFreebieForItem(self, itemId):
3974 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3975 
    args = getFreebieForItem_args()
3976 
    args.itemId = itemId
3977 
    args.write(self._oprot)
3978 
    self._oprot.writeMessageEnd()
3979 
    self._oprot.trans.flush()
3980 
 
3981 
  def recv_getFreebieForItem(self, ):
3982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3983 
    if mtype == TMessageType.EXCEPTION:
3984 
      x = TApplicationException()
3985 
      x.read(self._iprot)
3986 
      self._iprot.readMessageEnd()
3987 
      raise x
3988 
    result = getFreebieForItem_result()
3989 
    result.read(self._iprot)
3990 
    self._iprot.readMessageEnd()
3991 
    if result.success is not None:
3992 
      return result.success
3993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3994 
 
3995 
  def addOrUpdateFreebieForItem(self, freebieItem):
3996 
    """
3997 
    Parameters:
3998 
     - freebieItem
3999 
    """
4000 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4001 
    self.recv_addOrUpdateFreebieForItem()
4002 
 
4003 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4004 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4005 
    args = addOrUpdateFreebieForItem_args()
4006 
    args.freebieItem = freebieItem
4007 
    args.write(self._oprot)
4008 
    self._oprot.writeMessageEnd()
4009 
    self._oprot.trans.flush()
4010 
 
4011 
  def recv_addOrUpdateFreebieForItem(self, ):
4012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4013 
    if mtype == TMessageType.EXCEPTION:
4014 
      x = TApplicationException()
4015 
      x.read(self._iprot)
4016 
      self._iprot.readMessageEnd()
4017 
      raise x
4018 
    result = addOrUpdateFreebieForItem_result()
4019 
    result.read(self._iprot)
4020 
    self._iprot.readMessageEnd()
4021 
    return
4022 
 
7272 amit.gupta 4023 
  def addOrUpdateBrandInfo(self, brandInfo):
4024 
    """
4025 
    Parameters:
4026 
     - brandInfo
4027 
    """
4028 
    self.send_addOrUpdateBrandInfo(brandInfo)
4029 
    self.recv_addOrUpdateBrandInfo()
4030 
 
4031 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4032 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4033 
    args = addOrUpdateBrandInfo_args()
4034 
    args.brandInfo = brandInfo
4035 
    args.write(self._oprot)
4036 
    self._oprot.writeMessageEnd()
4037 
    self._oprot.trans.flush()
4038 
 
4039 
  def recv_addOrUpdateBrandInfo(self, ):
4040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4041 
    if mtype == TMessageType.EXCEPTION:
4042 
      x = TApplicationException()
4043 
      x.read(self._iprot)
4044 
      self._iprot.readMessageEnd()
4045 
      raise x
4046 
    result = addOrUpdateBrandInfo_result()
4047 
    result.read(self._iprot)
4048 
    self._iprot.readMessageEnd()
4049 
    return
4050 
 
4051 
  def getBrandInfo(self, ):
4052 
    self.send_getBrandInfo()
4053 
    return self.recv_getBrandInfo()
4054 
 
4055 
  def send_getBrandInfo(self, ):
4056 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4057 
    args = getBrandInfo_args()
4058 
    args.write(self._oprot)
4059 
    self._oprot.writeMessageEnd()
4060 
    self._oprot.trans.flush()
4061 
 
4062 
  def recv_getBrandInfo(self, ):
4063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4064 
    if mtype == TMessageType.EXCEPTION:
4065 
      x = TApplicationException()
4066 
      x.read(self._iprot)
4067 
      self._iprot.readMessageEnd()
4068 
      raise x
4069 
    result = getBrandInfo_result()
4070 
    result.read(self._iprot)
4071 
    self._iprot.readMessageEnd()
4072 
    if result.success is not None:
4073 
      return result.success
4074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4075 
 
7256 rajveer 4076 
  def getStorePricing(self, itemId):
4077 
    """
4078 
    Parameters:
4079 
     - itemId
4080 
    """
4081 
    self.send_getStorePricing(itemId)
4082 
    return self.recv_getStorePricing()
7190 amar.kumar 4083 
 
7256 rajveer 4084 
  def send_getStorePricing(self, itemId):
4085 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4086 
    args = getStorePricing_args()
4087 
    args.itemId = itemId
4088 
    args.write(self._oprot)
4089 
    self._oprot.writeMessageEnd()
4090 
    self._oprot.trans.flush()
4091 
 
4092 
  def recv_getStorePricing(self, ):
4093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4094 
    if mtype == TMessageType.EXCEPTION:
4095 
      x = TApplicationException()
4096 
      x.read(self._iprot)
4097 
      self._iprot.readMessageEnd()
4098 
      raise x
4099 
    result = getStorePricing_result()
4100 
    result.read(self._iprot)
4101 
    self._iprot.readMessageEnd()
4102 
    if result.success is not None:
4103 
      return result.success
4104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4105 
 
7306 rajveer 4106 
  def getStorePricings(self, itemIds):
4107 
    """
4108 
    Parameters:
4109 
     - itemIds
4110 
    """
4111 
    self.send_getStorePricings(itemIds)
4112 
    return self.recv_getStorePricings()
4113 
 
4114 
  def send_getStorePricings(self, itemIds):
4115 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4116 
    args = getStorePricings_args()
4117 
    args.itemIds = itemIds
4118 
    args.write(self._oprot)
4119 
    self._oprot.writeMessageEnd()
4120 
    self._oprot.trans.flush()
4121 
 
4122 
  def recv_getStorePricings(self, ):
4123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4124 
    if mtype == TMessageType.EXCEPTION:
4125 
      x = TApplicationException()
4126 
      x.read(self._iprot)
4127 
      self._iprot.readMessageEnd()
4128 
      raise x
4129 
    result = getStorePricings_result()
4130 
    result.read(self._iprot)
4131 
    self._iprot.readMessageEnd()
4132 
    if result.success is not None:
4133 
      return result.success
4134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4135 
 
7382 rajveer 4136 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4137 
    """
4138 
    Parameters:
4139 
     - sp
7382 rajveer 4140 
     - allColors
7265 rajveer 4141 
    """
7382 rajveer 4142 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4143 
    self.recv_updateStorePricing()
7256 rajveer 4144 
 
7382 rajveer 4145 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4146 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4147 
    args = updateStorePricing_args()
4148 
    args.sp = sp
7382 rajveer 4149 
    args.allColors = allColors
7265 rajveer 4150 
    args.write(self._oprot)
4151 
    self._oprot.writeMessageEnd()
4152 
    self._oprot.trans.flush()
4153 
 
4154 
  def recv_updateStorePricing(self, ):
4155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4156 
    if mtype == TMessageType.EXCEPTION:
4157 
      x = TApplicationException()
4158 
      x.read(self._iprot)
4159 
      self._iprot.readMessageEnd()
4160 
      raise x
4161 
    result = updateStorePricing_result()
4162 
    result.read(self._iprot)
4163 
    self._iprot.readMessageEnd()
4164 
    return
4165 
 
7281 kshitij.so 4166 
  def getAllAmazonListedItems(self, ):
4167 
    self.send_getAllAmazonListedItems()
4168 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4169 
 
7281 kshitij.so 4170 
  def send_getAllAmazonListedItems(self, ):
4171 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4172 
    args = getAllAmazonListedItems_args()
4173 
    args.write(self._oprot)
4174 
    self._oprot.writeMessageEnd()
4175 
    self._oprot.trans.flush()
4176 
 
4177 
  def recv_getAllAmazonListedItems(self, ):
4178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4179 
    if mtype == TMessageType.EXCEPTION:
4180 
      x = TApplicationException()
4181 
      x.read(self._iprot)
4182 
      self._iprot.readMessageEnd()
4183 
      raise x
4184 
    result = getAllAmazonListedItems_result()
4185 
    result.read(self._iprot)
4186 
    self._iprot.readMessageEnd()
4187 
    if result.success is not None:
4188 
      return result.success
4189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4190 
 
8619 kshitij.so 4191 
  def searchAmazonItems(self, searchTerm, offset, limit):
4192 
    """
4193 
    Parameters:
4194 
     - searchTerm
4195 
     - offset
4196 
     - limit
4197 
    """
4198 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4199 
    return self.recv_searchAmazonItems()
4200 
 
4201 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4202 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4203 
    args = searchAmazonItems_args()
4204 
    args.searchTerm = searchTerm
4205 
    args.offset = offset
4206 
    args.limit = limit
4207 
    args.write(self._oprot)
4208 
    self._oprot.writeMessageEnd()
4209 
    self._oprot.trans.flush()
4210 
 
4211 
  def recv_searchAmazonItems(self, ):
4212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4213 
    if mtype == TMessageType.EXCEPTION:
4214 
      x = TApplicationException()
4215 
      x.read(self._iprot)
4216 
      self._iprot.readMessageEnd()
4217 
      raise x
4218 
    result = searchAmazonItems_result()
4219 
    result.read(self._iprot)
4220 
    self._iprot.readMessageEnd()
4221 
    if result.success is not None:
4222 
      return result.success
4223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4224 
 
4225 
  def getAmazonSearchResultCount(self, searchTerm):
4226 
    """
4227 
    Parameters:
4228 
     - searchTerm
4229 
    """
4230 
    self.send_getAmazonSearchResultCount(searchTerm)
4231 
    return self.recv_getAmazonSearchResultCount()
4232 
 
4233 
  def send_getAmazonSearchResultCount(self, searchTerm):
4234 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4235 
    args = getAmazonSearchResultCount_args()
4236 
    args.searchTerm = searchTerm
4237 
    args.write(self._oprot)
4238 
    self._oprot.writeMessageEnd()
4239 
    self._oprot.trans.flush()
4240 
 
4241 
  def recv_getAmazonSearchResultCount(self, ):
4242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4243 
    if mtype == TMessageType.EXCEPTION:
4244 
      x = TApplicationException()
4245 
      x.read(self._iprot)
4246 
      self._iprot.readMessageEnd()
4247 
      raise x
4248 
    result = getAmazonSearchResultCount_result()
4249 
    result.read(self._iprot)
4250 
    self._iprot.readMessageEnd()
4251 
    if result.success is not None:
4252 
      return result.success
4253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4254 
 
4255 
  def getCountForAmazonlistedItems(self, ):
4256 
    self.send_getCountForAmazonlistedItems()
4257 
    return self.recv_getCountForAmazonlistedItems()
4258 
 
4259 
  def send_getCountForAmazonlistedItems(self, ):
4260 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4261 
    args = getCountForAmazonlistedItems_args()
4262 
    args.write(self._oprot)
4263 
    self._oprot.writeMessageEnd()
4264 
    self._oprot.trans.flush()
4265 
 
4266 
  def recv_getCountForAmazonlistedItems(self, ):
4267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4268 
    if mtype == TMessageType.EXCEPTION:
4269 
      x = TApplicationException()
4270 
      x.read(self._iprot)
4271 
      self._iprot.readMessageEnd()
4272 
      raise x
4273 
    result = getCountForAmazonlistedItems_result()
4274 
    result.read(self._iprot)
4275 
    self._iprot.readMessageEnd()
4276 
    if result.success is not None:
4277 
      return result.success
4278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4279 
 
7281 kshitij.so 4280 
  def getAmazonItemDetails(self, itemId):
4281 
    """
4282 
    Parameters:
4283 
     - itemId
4284 
    """
4285 
    self.send_getAmazonItemDetails(itemId)
4286 
    return self.recv_getAmazonItemDetails()
4287 
 
4288 
  def send_getAmazonItemDetails(self, itemId):
4289 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4290 
    args = getAmazonItemDetails_args()
4291 
    args.itemId = itemId
4292 
    args.write(self._oprot)
4293 
    self._oprot.writeMessageEnd()
4294 
    self._oprot.trans.flush()
4295 
 
4296 
  def recv_getAmazonItemDetails(self, ):
4297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4298 
    if mtype == TMessageType.EXCEPTION:
4299 
      x = TApplicationException()
4300 
      x.read(self._iprot)
4301 
      self._iprot.readMessageEnd()
4302 
      raise x
4303 
    result = getAmazonItemDetails_result()
4304 
    result.read(self._iprot)
4305 
    self._iprot.readMessageEnd()
4306 
    if result.success is not None:
4307 
      return result.success
4308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4309 
 
8168 kshitij.so 4310 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4311 
    """
4312 
    Parameters:
8168 kshitij.so 4313 
     - amazonlisted
7281 kshitij.so 4314 
    """
8168 kshitij.so 4315 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4316 
    self.recv_updateAmazonItemDetails()
4317 
 
8168 kshitij.so 4318 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4319 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4320 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4321 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_updateAmazonItemDetails(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = updateAmazonItemDetails_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    return
4337 
 
4338 
  def addAmazonItem(self, amazonlisted):
4339 
    """
4340 
    Parameters:
4341 
     - amazonlisted
4342 
    """
4343 
    self.send_addAmazonItem(amazonlisted)
4344 
    self.recv_addAmazonItem()
4345 
 
4346 
  def send_addAmazonItem(self, amazonlisted):
4347 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4348 
    args = addAmazonItem_args()
4349 
    args.amazonlisted = amazonlisted
4350 
    args.write(self._oprot)
4351 
    self._oprot.writeMessageEnd()
4352 
    self._oprot.trans.flush()
4353 
 
4354 
  def recv_addAmazonItem(self, ):
4355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4356 
    if mtype == TMessageType.EXCEPTION:
4357 
      x = TApplicationException()
4358 
      x.read(self._iprot)
4359 
      self._iprot.readMessageEnd()
4360 
      raise x
4361 
    result = addAmazonItem_result()
4362 
    result.read(self._iprot)
4363 
    self._iprot.readMessageEnd()
4364 
    return
4365 
 
7291 vikram.rag 4366 
  def getAsinItems(self, ):
4367 
    self.send_getAsinItems()
4368 
    return self.recv_getAsinItems()
7281 kshitij.so 4369 
 
7291 vikram.rag 4370 
  def send_getAsinItems(self, ):
4371 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4372 
    args = getAsinItems_args()
4373 
    args.write(self._oprot)
4374 
    self._oprot.writeMessageEnd()
4375 
    self._oprot.trans.flush()
4376 
 
4377 
  def recv_getAsinItems(self, ):
4378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4379 
    if mtype == TMessageType.EXCEPTION:
4380 
      x = TApplicationException()
4381 
      x.read(self._iprot)
4382 
      self._iprot.readMessageEnd()
4383 
      raise x
4384 
    result = getAsinItems_result()
4385 
    result.read(self._iprot)
4386 
    self._iprot.readMessageEnd()
4387 
    if result.success is not None:
4388 
      return result.success
4389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4390 
 
4391 
  def getAllFbaListedItems(self, ):
4392 
    self.send_getAllFbaListedItems()
4393 
    return self.recv_getAllFbaListedItems()
4394 
 
4395 
  def send_getAllFbaListedItems(self, ):
4396 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4397 
    args = getAllFbaListedItems_args()
4398 
    args.write(self._oprot)
4399 
    self._oprot.writeMessageEnd()
4400 
    self._oprot.trans.flush()
4401 
 
4402 
  def recv_getAllFbaListedItems(self, ):
4403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4404 
    if mtype == TMessageType.EXCEPTION:
4405 
      x = TApplicationException()
4406 
      x.read(self._iprot)
4407 
      self._iprot.readMessageEnd()
4408 
      raise x
4409 
    result = getAllFbaListedItems_result()
4410 
    result.read(self._iprot)
4411 
    self._iprot.readMessageEnd()
4412 
    if result.success is not None:
4413 
      return result.success
4414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4415 
 
4416 
  def getAllNonFbaListedItems(self, ):
4417 
    self.send_getAllNonFbaListedItems()
4418 
    return self.recv_getAllNonFbaListedItems()
4419 
 
4420 
  def send_getAllNonFbaListedItems(self, ):
4421 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4422 
    args = getAllNonFbaListedItems_args()
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_getAllNonFbaListedItems(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = getAllNonFbaListedItems_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    if result.success is not None:
4438 
      return result.success
4439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4440 
 
7460 kshitij.so 4441 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4442 
    """
4443 
    Parameters:
4444 
     - itemId
4445 
     - holdInventory
4446 
     - defaultInventory
4447 
    """
4448 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4449 
    return self.recv_updateItemInventory()
7291 vikram.rag 4450 
 
7460 kshitij.so 4451 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4452 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4453 
    args = updateItemInventory_args()
4454 
    args.itemId = itemId
4455 
    args.holdInventory = holdInventory
4456 
    args.defaultInventory = defaultInventory
4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4461 
  def recv_updateItemInventory(self, ):
4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4468 
    result = updateItemInventory_result()
4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.success is not None:
4472 
      return result.success
4473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4474 
 
7770 kshitij.so 4475 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4476 
    """
4477 
    Parameters:
4478 
     - type
4479 
     - sku
4480 
     - timestamp
4481 
    """
4482 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4483 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4484 
 
7770 kshitij.so 4485 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4486 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4487 
    args = updateTimestampForAmazonFeeds_args()
4488 
    args.type = type
4489 
    args.sku = sku
4490 
    args.timestamp = timestamp
4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_updateTimestampForAmazonFeeds(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = updateTimestampForAmazonFeeds_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    if result.success is not None:
4506 
      return result.success
4507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4508 
 
7897 amar.kumar 4509 
  def getAllParentCategories(self, ):
4510 
    self.send_getAllParentCategories()
4511 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4512 
 
7897 amar.kumar 4513 
  def send_getAllParentCategories(self, ):
4514 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4515 
    args = getAllParentCategories_args()
4516 
    args.write(self._oprot)
4517 
    self._oprot.writeMessageEnd()
4518 
    self._oprot.trans.flush()
4519 
 
4520 
  def recv_getAllParentCategories(self, ):
4521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4522 
    if mtype == TMessageType.EXCEPTION:
4523 
      x = TApplicationException()
4524 
      x.read(self._iprot)
4525 
      self._iprot.readMessageEnd()
4526 
      raise x
4527 
    result = getAllParentCategories_result()
4528 
    result.read(self._iprot)
4529 
    self._iprot.readMessageEnd()
4530 
    if result.success is not None:
4531 
      return result.success
4532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4533 
 
7977 kshitij.so 4534 
  def addPageViewEvent(self, pageViewEvents):
4535 
    """
4536 
    Parameters:
4537 
     - pageViewEvents
4538 
    """
4539 
    self.send_addPageViewEvent(pageViewEvents)
4540 
    self.recv_addPageViewEvent()
7897 amar.kumar 4541 
 
7977 kshitij.so 4542 
  def send_addPageViewEvent(self, pageViewEvents):
4543 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4544 
    args = addPageViewEvent_args()
4545 
    args.pageViewEvents = pageViewEvents
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_addPageViewEvent(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = addPageViewEvent_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    return
4561 
 
4562 
  def addCartEvent(self, cartEvents):
4563 
    """
4564 
    Parameters:
4565 
     - cartEvents
4566 
    """
4567 
    self.send_addCartEvent(cartEvents)
4568 
    self.recv_addCartEvent()
4569 
 
4570 
  def send_addCartEvent(self, cartEvents):
4571 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4572 
    args = addCartEvent_args()
4573 
    args.cartEvents = cartEvents
4574 
    args.write(self._oprot)
4575 
    self._oprot.writeMessageEnd()
4576 
    self._oprot.trans.flush()
4577 
 
4578 
  def recv_addCartEvent(self, ):
4579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4580 
    if mtype == TMessageType.EXCEPTION:
4581 
      x = TApplicationException()
4582 
      x.read(self._iprot)
4583 
      self._iprot.readMessageEnd()
4584 
      raise x
4585 
    result = addCartEvent_result()
4586 
    result.read(self._iprot)
4587 
    self._iprot.readMessageEnd()
4588 
    return
4589 
 
8182 amar.kumar 4590 
  def addEbayItem(self, ebayItem):
4591 
    """
4592 
    Parameters:
4593 
     - ebayItem
4594 
    """
4595 
    self.send_addEbayItem(ebayItem)
4596 
    self.recv_addEbayItem()
4597 
 
4598 
  def send_addEbayItem(self, ebayItem):
4599 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4600 
    args = addEbayItem_args()
4601 
    args.ebayItem = ebayItem
4602 
    args.write(self._oprot)
4603 
    self._oprot.writeMessageEnd()
4604 
    self._oprot.trans.flush()
4605 
 
4606 
  def recv_addEbayItem(self, ):
4607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4608 
    if mtype == TMessageType.EXCEPTION:
4609 
      x = TApplicationException()
4610 
      x.read(self._iprot)
4611 
      self._iprot.readMessageEnd()
4612 
      raise x
4613 
    result = addEbayItem_result()
4614 
    result.read(self._iprot)
4615 
    self._iprot.readMessageEnd()
4616 
    return
4617 
 
4618 
  def getEbayItem(self, listingId):
4619 
    """
4620 
    Parameters:
4621 
     - listingId
4622 
    """
4623 
    self.send_getEbayItem(listingId)
4624 
    return self.recv_getEbayItem()
4625 
 
4626 
  def send_getEbayItem(self, listingId):
4627 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4628 
    args = getEbayItem_args()
4629 
    args.listingId = listingId
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_getEbayItem(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = getEbayItem_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.success is not None:
4645 
      return result.success
4646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4647 
 
4648 
  def updateEbayItem(self, ebayItem):
4649 
    """
4650 
    Parameters:
4651 
     - ebayItem
4652 
    """
4653 
    self.send_updateEbayItem(ebayItem)
4654 
    self.recv_updateEbayItem()
4655 
 
4656 
  def send_updateEbayItem(self, ebayItem):
4657 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4658 
    args = updateEbayItem_args()
4659 
    args.ebayItem = ebayItem
4660 
    args.write(self._oprot)
4661 
    self._oprot.writeMessageEnd()
4662 
    self._oprot.trans.flush()
4663 
 
4664 
  def recv_updateEbayItem(self, ):
4665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4666 
    if mtype == TMessageType.EXCEPTION:
4667 
      x = TApplicationException()
4668 
      x.read(self._iprot)
4669 
      self._iprot.readMessageEnd()
4670 
      raise x
4671 
    result = updateEbayItem_result()
4672 
    result.read(self._iprot)
4673 
    self._iprot.readMessageEnd()
4674 
    return
4675 
 
8139 kshitij.so 4676 
  def getAmazonListedItems(self, offset, limit):
4677 
    """
4678 
    Parameters:
4679 
     - offset
4680 
     - limit
4681 
    """
4682 
    self.send_getAmazonListedItems(offset, limit)
4683 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4684 
 
8139 kshitij.so 4685 
  def send_getAmazonListedItems(self, offset, limit):
4686 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4687 
    args = getAmazonListedItems_args()
4688 
    args.offset = offset
4689 
    args.limit = limit
4690 
    args.write(self._oprot)
4691 
    self._oprot.writeMessageEnd()
4692 
    self._oprot.trans.flush()
4693 
 
4694 
  def recv_getAmazonListedItems(self, ):
4695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4696 
    if mtype == TMessageType.EXCEPTION:
4697 
      x = TApplicationException()
4698 
      x.read(self._iprot)
4699 
      self._iprot.readMessageEnd()
4700 
      raise x
4701 
    result = getAmazonListedItems_result()
4702 
    result.read(self._iprot)
4703 
    self._iprot.readMessageEnd()
4704 
    if result.success is not None:
4705 
      return result.success
4706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4707 
 
8168 kshitij.so 4708 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4709 
    """
4710 
    Parameters:
4711 
     - amazonlisted
4712 
    """
4713 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4714 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4715 
 
8168 kshitij.so 4716 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4717 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4718 
    args = updateAmazonAttributesInBulk_args()
4719 
    args.amazonlisted = amazonlisted
4720 
    args.write(self._oprot)
4721 
    self._oprot.writeMessageEnd()
4722 
    self._oprot.trans.flush()
4723 
 
4724 
  def recv_updateAmazonAttributesInBulk(self, ):
4725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4726 
    if mtype == TMessageType.EXCEPTION:
4727 
      x = TApplicationException()
4728 
      x.read(self._iprot)
4729 
      self._iprot.readMessageEnd()
4730 
      raise x
4731 
    result = updateAmazonAttributesInBulk_result()
4732 
    result.read(self._iprot)
4733 
    self._iprot.readMessageEnd()
4734 
    if result.success is not None:
4735 
      return result.success
4736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4737 
 
8379 vikram.rag 4738 
  def getAllItemstoListOnFba(self, ):
4739 
    self.send_getAllItemstoListOnFba()
4740 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4741 
 
8379 vikram.rag 4742 
  def send_getAllItemstoListOnFba(self, ):
4743 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4744 
    args = getAllItemstoListOnFba_args()
4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_getAllItemstoListOnFba(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = getAllItemstoListOnFba_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    if result.success is not None:
4760 
      return result.success
4761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4762 
 
4763 
  def getAllItemstoListOnNonFba(self, ):
4764 
    self.send_getAllItemstoListOnNonFba()
4765 
    return self.recv_getAllItemstoListOnNonFba()
4766 
 
4767 
  def send_getAllItemstoListOnNonFba(self, ):
4768 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4769 
    args = getAllItemstoListOnNonFba_args()
4770 
    args.write(self._oprot)
4771 
    self._oprot.writeMessageEnd()
4772 
    self._oprot.trans.flush()
4773 
 
4774 
  def recv_getAllItemstoListOnNonFba(self, ):
4775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4776 
    if mtype == TMessageType.EXCEPTION:
4777 
      x = TApplicationException()
4778 
      x.read(self._iprot)
4779 
      self._iprot.readMessageEnd()
4780 
      raise x
4781 
    result = getAllItemstoListOnNonFba_result()
4782 
    result.read(self._iprot)
4783 
    self._iprot.readMessageEnd()
4784 
    if result.success is not None:
4785 
      return result.success
4786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4787 
 
8619 kshitij.so 4788 
  def updateAsin(self, item):
4789 
    """
4790 
    Parameters:
4791 
     - item
4792 
    """
4793 
    self.send_updateAsin(item)
4794 
    self.recv_updateAsin()
8616 vikram.rag 4795 
 
8619 kshitij.so 4796 
  def send_updateAsin(self, item):
4797 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4798 
    args = updateAsin_args()
4799 
    args.item = item
4800 
    args.write(self._oprot)
4801 
    self._oprot.writeMessageEnd()
4802 
    self._oprot.trans.flush()
4803 
 
4804 
  def recv_updateAsin(self, ):
4805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4806 
    if mtype == TMessageType.EXCEPTION:
4807 
      x = TApplicationException()
4808 
      x.read(self._iprot)
4809 
      self._iprot.readMessageEnd()
4810 
      raise x
4811 
    result = updateAsin_result()
4812 
    result.read(self._iprot)
4813 
    self._iprot.readMessageEnd()
4814 
    return
4815 
 
8739 vikram.rag 4816 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4817 
    """
4818 
    Parameters:
4819 
     - snapdealitem
4820 
    """
4821 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4822 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4823 
 
8739 vikram.rag 4824 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4825 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4826 
    args = addOrUpdateSnapdealItem_args()
4827 
    args.snapdealitem = snapdealitem
4828 
    args.write(self._oprot)
4829 
    self._oprot.writeMessageEnd()
4830 
    self._oprot.trans.flush()
4831 
 
4832 
  def recv_addOrUpdateSnapdealItem(self, ):
4833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4834 
    if mtype == TMessageType.EXCEPTION:
4835 
      x = TApplicationException()
4836 
      x.read(self._iprot)
4837 
      self._iprot.readMessageEnd()
4838 
      raise x
4839 
    result = addOrUpdateSnapdealItem_result()
4840 
    result.read(self._iprot)
4841 
    self._iprot.readMessageEnd()
4842 
    if result.success is not None:
4843 
      return result.success
4844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4845 
 
4846 
  def getSnapdealItem(self, item_id):
4847 
    """
4848 
    Parameters:
4849 
     - item_id
4850 
    """
4851 
    self.send_getSnapdealItem(item_id)
4852 
    return self.recv_getSnapdealItem()
4853 
 
4854 
  def send_getSnapdealItem(self, item_id):
4855 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4856 
    args = getSnapdealItem_args()
4857 
    args.item_id = item_id
4858 
    args.write(self._oprot)
4859 
    self._oprot.writeMessageEnd()
4860 
    self._oprot.trans.flush()
4861 
 
4862 
  def recv_getSnapdealItem(self, ):
4863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4864 
    if mtype == TMessageType.EXCEPTION:
4865 
      x = TApplicationException()
4866 
      x.read(self._iprot)
4867 
      self._iprot.readMessageEnd()
4868 
      raise x
4869 
    result = getSnapdealItem_result()
4870 
    result.read(self._iprot)
4871 
    self._iprot.readMessageEnd()
4872 
    if result.success is not None:
4873 
      return result.success
4874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4875 
 
9242 kshitij.so 4876 
  def getSnapdealItemDetails(self, item_id):
4877 
    """
4878 
    Parameters:
4879 
     - item_id
4880 
    """
4881 
    self.send_getSnapdealItemDetails(item_id)
4882 
    return self.recv_getSnapdealItemDetails()
4883 
 
4884 
  def send_getSnapdealItemDetails(self, item_id):
4885 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4886 
    args = getSnapdealItemDetails_args()
4887 
    args.item_id = item_id
4888 
    args.write(self._oprot)
4889 
    self._oprot.writeMessageEnd()
4890 
    self._oprot.trans.flush()
4891 
 
4892 
  def recv_getSnapdealItemDetails(self, ):
4893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4894 
    if mtype == TMessageType.EXCEPTION:
4895 
      x = TApplicationException()
4896 
      x.read(self._iprot)
4897 
      self._iprot.readMessageEnd()
4898 
      raise x
4899 
    result = getSnapdealItemDetails_result()
4900 
    result.read(self._iprot)
4901 
    self._iprot.readMessageEnd()
4902 
    if result.success is not None:
4903 
      return result.success
4904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4905 
 
8739 vikram.rag 4906 
  def getAllSnapdealItems(self, ):
4907 
    self.send_getAllSnapdealItems()
4908 
    return self.recv_getAllSnapdealItems()
4909 
 
4910 
  def send_getAllSnapdealItems(self, ):
4911 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4912 
    args = getAllSnapdealItems_args()
4913 
    args.write(self._oprot)
4914 
    self._oprot.writeMessageEnd()
4915 
    self._oprot.trans.flush()
4916 
 
4917 
  def recv_getAllSnapdealItems(self, ):
4918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4919 
    if mtype == TMessageType.EXCEPTION:
4920 
      x = TApplicationException()
4921 
      x.read(self._iprot)
4922 
      self._iprot.readMessageEnd()
4923 
      raise x
4924 
    result = getAllSnapdealItems_result()
4925 
    result.read(self._iprot)
4926 
    self._iprot.readMessageEnd()
4927 
    if result.success is not None:
4928 
      return result.success
4929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4930 
 
9242 kshitij.so 4931 
  def getSnapdealItems(self, offset, limit):
4932 
    """
4933 
    Parameters:
4934 
     - offset
4935 
     - limit
4936 
    """
4937 
    self.send_getSnapdealItems(offset, limit)
4938 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4939 
 
9242 kshitij.so 4940 
  def send_getSnapdealItems(self, offset, limit):
4941 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4942 
    args = getSnapdealItems_args()
4943 
    args.offset = offset
4944 
    args.limit = limit
4945 
    args.write(self._oprot)
4946 
    self._oprot.writeMessageEnd()
4947 
    self._oprot.trans.flush()
4948 
 
4949 
  def recv_getSnapdealItems(self, ):
4950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4951 
    if mtype == TMessageType.EXCEPTION:
4952 
      x = TApplicationException()
4953 
      x.read(self._iprot)
4954 
      self._iprot.readMessageEnd()
4955 
      raise x
4956 
    result = getSnapdealItems_result()
4957 
    result.read(self._iprot)
4958 
    self._iprot.readMessageEnd()
4959 
    if result.success is not None:
4960 
      return result.success
4961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4962 
 
4963 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4964 
    """
4965 
    Parameters:
4966 
     - searchTerm
4967 
     - offset
4968 
     - limit
4969 
    """
4970 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4971 
    return self.recv_searchSnapdealItems()
4972 
 
4973 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4974 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4975 
    args = searchSnapdealItems_args()
4976 
    args.searchTerm = searchTerm
4977 
    args.offset = offset
4978 
    args.limit = limit
4979 
    args.write(self._oprot)
4980 
    self._oprot.writeMessageEnd()
4981 
    self._oprot.trans.flush()
4982 
 
4983 
  def recv_searchSnapdealItems(self, ):
4984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4985 
    if mtype == TMessageType.EXCEPTION:
4986 
      x = TApplicationException()
4987 
      x.read(self._iprot)
4988 
      self._iprot.readMessageEnd()
4989 
      raise x
4990 
    result = searchSnapdealItems_result()
4991 
    result.read(self._iprot)
4992 
    self._iprot.readMessageEnd()
4993 
    if result.success is not None:
4994 
      return result.success
4995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4996 
 
4997 
  def getCountForSnapdealItems(self, ):
4998 
    self.send_getCountForSnapdealItems()
4999 
    return self.recv_getCountForSnapdealItems()
5000 
 
5001 
  def send_getCountForSnapdealItems(self, ):
5002 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5003 
    args = getCountForSnapdealItems_args()
5004 
    args.write(self._oprot)
5005 
    self._oprot.writeMessageEnd()
5006 
    self._oprot.trans.flush()
5007 
 
5008 
  def recv_getCountForSnapdealItems(self, ):
5009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5010 
    if mtype == TMessageType.EXCEPTION:
5011 
      x = TApplicationException()
5012 
      x.read(self._iprot)
5013 
      self._iprot.readMessageEnd()
5014 
      raise x
5015 
    result = getCountForSnapdealItems_result()
5016 
    result.read(self._iprot)
5017 
    self._iprot.readMessageEnd()
5018 
    if result.success is not None:
5019 
      return result.success
5020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5021 
 
5022 
  def getSnapdealSearchResultCount(self, searchTerm):
5023 
    """
5024 
    Parameters:
5025 
     - searchTerm
5026 
    """
5027 
    self.send_getSnapdealSearchResultCount(searchTerm)
5028 
    return self.recv_getSnapdealSearchResultCount()
5029 
 
5030 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5031 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5032 
    args = getSnapdealSearchResultCount_args()
5033 
    args.searchTerm = searchTerm
5034 
    args.write(self._oprot)
5035 
    self._oprot.writeMessageEnd()
5036 
    self._oprot.trans.flush()
5037 
 
5038 
  def recv_getSnapdealSearchResultCount(self, ):
5039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5040 
    if mtype == TMessageType.EXCEPTION:
5041 
      x = TApplicationException()
5042 
      x.read(self._iprot)
5043 
      self._iprot.readMessageEnd()
5044 
      raise x
5045 
    result = getSnapdealSearchResultCount_result()
5046 
    result.read(self._iprot)
5047 
    self._iprot.readMessageEnd()
5048 
    if result.success is not None:
5049 
      return result.success
5050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5051 
 
9299 kshitij.so 5052 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5053 
    """
5054 
    Parameters:
5055 
     - itemId
5056 
     - insurerType
5057 
    """
5058 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5059 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5060 
 
9299 kshitij.so 5061 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5062 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5063 
    args = getPrefferedInsurerForItem_args()
5064 
    args.itemId = itemId
5065 
    args.insurerType = insurerType
5066 
    args.write(self._oprot)
5067 
    self._oprot.writeMessageEnd()
5068 
    self._oprot.trans.flush()
5069 
 
5070 
  def recv_getPrefferedInsurerForItem(self, ):
5071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5072 
    if mtype == TMessageType.EXCEPTION:
5073 
      x = TApplicationException()
5074 
      x.read(self._iprot)
5075 
      self._iprot.readMessageEnd()
5076 
      raise x
5077 
    result = getPrefferedInsurerForItem_result()
5078 
    result.read(self._iprot)
5079 
    self._iprot.readMessageEnd()
5080 
    if result.success is not None:
5081 
      return result.success
5082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5083 
 
9456 vikram.rag 5084 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5085 
    """
5086 
    Parameters:
5087 
     - skuAtSnapdeal
5088 
    """
5089 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5090 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5091 
 
9456 vikram.rag 5092 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5093 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5094 
    args = getSnapdealItembySkuAtSnapdeal_args()
5095 
    args.skuAtSnapdeal = skuAtSnapdeal
5096 
    args.write(self._oprot)
5097 
    self._oprot.writeMessageEnd()
5098 
    self._oprot.trans.flush()
5099 
 
5100 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5102 
    if mtype == TMessageType.EXCEPTION:
5103 
      x = TApplicationException()
5104 
      x.read(self._iprot)
5105 
      self._iprot.readMessageEnd()
5106 
      raise x
5107 
    result = getSnapdealItembySkuAtSnapdeal_result()
5108 
    result.read(self._iprot)
5109 
    self._iprot.readMessageEnd()
5110 
    if result.success is not None:
5111 
      return result.success
5112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5113 
 
9621 manish.sha 5114 
  def getProductFeedSubmit(self, catalogItemId):
5115 
    """
5116 
    Parameters:
5117 
     - catalogItemId
5118 
    """
5119 
    self.send_getProductFeedSubmit(catalogItemId)
5120 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5121 
 
9621 manish.sha 5122 
  def send_getProductFeedSubmit(self, catalogItemId):
5123 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5124 
    args = getProductFeedSubmit_args()
5125 
    args.catalogItemId = catalogItemId
5126 
    args.write(self._oprot)
5127 
    self._oprot.writeMessageEnd()
5128 
    self._oprot.trans.flush()
5129 
 
5130 
  def recv_getProductFeedSubmit(self, ):
5131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5132 
    if mtype == TMessageType.EXCEPTION:
5133 
      x = TApplicationException()
5134 
      x.read(self._iprot)
5135 
      self._iprot.readMessageEnd()
5136 
      raise x
5137 
    result = getProductFeedSubmit_result()
5138 
    result.read(self._iprot)
5139 
    self._iprot.readMessageEnd()
5140 
    if result.success is not None:
5141 
      return result.success
5142 
    if result.cex is not None:
5143 
      raise result.cex
5144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5145 
 
5146 
  def addProductFeedSubmit(self, productFeedSubmit):
5147 
    """
5148 
    Parameters:
5149 
     - productFeedSubmit
5150 
    """
5151 
    self.send_addProductFeedSubmit(productFeedSubmit)
5152 
    return self.recv_addProductFeedSubmit()
5153 
 
5154 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5155 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5156 
    args = addProductFeedSubmit_args()
5157 
    args.productFeedSubmit = productFeedSubmit
5158 
    args.write(self._oprot)
5159 
    self._oprot.writeMessageEnd()
5160 
    self._oprot.trans.flush()
5161 
 
5162 
  def recv_addProductFeedSubmit(self, ):
5163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5164 
    if mtype == TMessageType.EXCEPTION:
5165 
      x = TApplicationException()
5166 
      x.read(self._iprot)
5167 
      self._iprot.readMessageEnd()
5168 
      raise x
5169 
    result = addProductFeedSubmit_result()
5170 
    result.read(self._iprot)
5171 
    self._iprot.readMessageEnd()
5172 
    if result.success is not None:
5173 
      return result.success
5174 
    if result.cex is not None:
5175 
      raise result.cex
5176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5177 
 
5178 
  def updateProductFeedSubmit(self, productFeedSubmit):
5179 
    """
5180 
    Parameters:
5181 
     - productFeedSubmit
5182 
    """
5183 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5184 
    return self.recv_updateProductFeedSubmit()
5185 
 
5186 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5187 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5188 
    args = updateProductFeedSubmit_args()
5189 
    args.productFeedSubmit = productFeedSubmit
5190 
    args.write(self._oprot)
5191 
    self._oprot.writeMessageEnd()
5192 
    self._oprot.trans.flush()
5193 
 
5194 
  def recv_updateProductFeedSubmit(self, ):
5195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5196 
    if mtype == TMessageType.EXCEPTION:
5197 
      x = TApplicationException()
5198 
      x.read(self._iprot)
5199 
      self._iprot.readMessageEnd()
5200 
      raise x
5201 
    result = updateProductFeedSubmit_result()
5202 
    result.read(self._iprot)
5203 
    self._iprot.readMessageEnd()
5204 
    if result.success is not None:
5205 
      return result.success
5206 
    if result.cex is not None:
5207 
      raise result.cex
5208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5209 
 
5210 
  def deleteProductFeedSubmit(self, catalogItemId):
5211 
    """
5212 
    Parameters:
5213 
     - catalogItemId
5214 
    """
5215 
    self.send_deleteProductFeedSubmit(catalogItemId)
5216 
    return self.recv_deleteProductFeedSubmit()
5217 
 
5218 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5219 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5220 
    args = deleteProductFeedSubmit_args()
5221 
    args.catalogItemId = catalogItemId
5222 
    args.write(self._oprot)
5223 
    self._oprot.writeMessageEnd()
5224 
    self._oprot.trans.flush()
5225 
 
5226 
  def recv_deleteProductFeedSubmit(self, ):
5227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5228 
    if mtype == TMessageType.EXCEPTION:
5229 
      x = TApplicationException()
5230 
      x.read(self._iprot)
5231 
      self._iprot.readMessageEnd()
5232 
      raise x
5233 
    result = deleteProductFeedSubmit_result()
5234 
    result.read(self._iprot)
5235 
    self._iprot.readMessageEnd()
5236 
    if result.success is not None:
5237 
      return result.success
5238 
    if result.cex is not None:
5239 
      raise result.cex
5240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5241 
 
5242 
  def getAllProductFeedSubmit(self, ):
5243 
    self.send_getAllProductFeedSubmit()
5244 
    return self.recv_getAllProductFeedSubmit()
5245 
 
5246 
  def send_getAllProductFeedSubmit(self, ):
5247 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5248 
    args = getAllProductFeedSubmit_args()
5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5253 
  def recv_getAllProductFeedSubmit(self, ):
5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5260 
    result = getAllProductFeedSubmit_result()
5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.success is not None:
5264 
      return result.success
5265 
    if result.cex is not None:
5266 
      raise result.cex
5267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5268 
 
9724 kshitij.so 5269 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5270 
    """
5271 
    Parameters:
5272 
     - itemId
5273 
     - sourceId
5274 
    """
5275 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5276 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5277 
 
9724 kshitij.so 5278 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5279 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5280 
    args = getMarketplacedetailsForItem_args()
5281 
    args.itemId = itemId
5282 
    args.sourceId = sourceId
5283 
    args.write(self._oprot)
5284 
    self._oprot.writeMessageEnd()
5285 
    self._oprot.trans.flush()
5286 
 
5287 
  def recv_getMarketplacedetailsForItem(self, ):
5288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5289 
    if mtype == TMessageType.EXCEPTION:
5290 
      x = TApplicationException()
5291 
      x.read(self._iprot)
5292 
      self._iprot.readMessageEnd()
5293 
      raise x
5294 
    result = getMarketplacedetailsForItem_result()
5295 
    result.read(self._iprot)
5296 
    self._iprot.readMessageEnd()
5297 
    if result.success is not None:
5298 
      return result.success
5299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5300 
 
5301 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5302 
    """
5303 
    Parameters:
5304 
     - marketPlaceItem
5305 
    """
5306 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5307 
    return self.recv_updateMarketplaceAttributesForItem()
5308 
 
5309 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5310 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5311 
    args = updateMarketplaceAttributesForItem_args()
5312 
    args.marketPlaceItem = marketPlaceItem
5313 
    args.write(self._oprot)
5314 
    self._oprot.writeMessageEnd()
5315 
    self._oprot.trans.flush()
5316 
 
5317 
  def recv_updateMarketplaceAttributesForItem(self, ):
5318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5319 
    if mtype == TMessageType.EXCEPTION:
5320 
      x = TApplicationException()
5321 
      x.read(self._iprot)
5322 
      self._iprot.readMessageEnd()
5323 
      raise x
5324 
    result = updateMarketplaceAttributesForItem_result()
5325 
    result.read(self._iprot)
5326 
    self._iprot.readMessageEnd()
5327 
    if result.success is not None:
5328 
      return result.success
5329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5330 
 
9779 kshitij.so 5331 
  def getCostingForMarketplace(self, source, item_id):
5332 
    """
5333 
    Parameters:
5334 
     - source
5335 
     - item_id
5336 
    """
5337 
    self.send_getCostingForMarketplace(source, item_id)
5338 
    return self.recv_getCostingForMarketplace()
5339 
 
5340 
  def send_getCostingForMarketplace(self, source, item_id):
5341 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5342 
    args = getCostingForMarketplace_args()
5343 
    args.source = source
5344 
    args.item_id = item_id
5345 
    args.write(self._oprot)
5346 
    self._oprot.writeMessageEnd()
5347 
    self._oprot.trans.flush()
5348 
 
5349 
  def recv_getCostingForMarketplace(self, ):
5350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5351 
    if mtype == TMessageType.EXCEPTION:
5352 
      x = TApplicationException()
5353 
      x.read(self._iprot)
5354 
      self._iprot.readMessageEnd()
5355 
      raise x
5356 
    result = getCostingForMarketplace_result()
5357 
    result.read(self._iprot)
5358 
    self._iprot.readMessageEnd()
5359 
    if result.success is not None:
5360 
      return result.success
5361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5362 
 
9776 vikram.rag 5363 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5364 
    """
5365 
    Parameters:
5366 
     - source
5367 
    """
5368 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5369 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5370 
 
9776 vikram.rag 5371 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5372 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5373 
    args = getMarketPlaceItemsForPriceUpdate_args()
5374 
    args.source = source
5375 
    args.write(self._oprot)
5376 
    self._oprot.writeMessageEnd()
5377 
    self._oprot.trans.flush()
5378 
 
5379 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5381 
    if mtype == TMessageType.EXCEPTION:
5382 
      x = TApplicationException()
5383 
      x.read(self._iprot)
5384 
      self._iprot.readMessageEnd()
5385 
      raise x
5386 
    result = getMarketPlaceItemsForPriceUpdate_result()
5387 
    result.read(self._iprot)
5388 
    self._iprot.readMessageEnd()
5389 
    if result.success is not None:
5390 
      return result.success
5391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5392 
 
9816 kshitij.so 5393 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5394 
    """
5395 
    Parameters:
5396 
     - skulist
5397 
     - timestamp
9816 kshitij.so 5398 
     - source
9776 vikram.rag 5399 
    """
9816 kshitij.so 5400 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5401 
    self.recv_updateMarketPlacePriceUpdateStatus()
5402 
 
9816 kshitij.so 5403 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5404 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5405 
    args = updateMarketPlacePriceUpdateStatus_args()
5406 
    args.skulist = skulist
5407 
    args.timestamp = timestamp
9816 kshitij.so 5408 
    args.source = source
9776 vikram.rag 5409 
    args.write(self._oprot)
5410 
    self._oprot.writeMessageEnd()
5411 
    self._oprot.trans.flush()
5412 
 
5413 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5415 
    if mtype == TMessageType.EXCEPTION:
5416 
      x = TApplicationException()
5417 
      x.read(self._iprot)
5418 
      self._iprot.readMessageEnd()
5419 
      raise x
5420 
    result = updateMarketPlacePriceUpdateStatus_result()
5421 
    result.read(self._iprot)
5422 
    self._iprot.readMessageEnd()
5423 
    return
5424 
 
9861 rajveer 5425 
  def updateItemHoldInventory(self, itemHoldMap):
5426 
    """
5427 
    Parameters:
5428 
     - itemHoldMap
5429 
    """
5430 
    self.send_updateItemHoldInventory(itemHoldMap)
5431 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5432 
 
9861 rajveer 5433 
  def send_updateItemHoldInventory(self, itemHoldMap):
5434 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5435 
    args = updateItemHoldInventory_args()
5436 
    args.itemHoldMap = itemHoldMap
5437 
    args.write(self._oprot)
5438 
    self._oprot.writeMessageEnd()
5439 
    self._oprot.trans.flush()
5440 
 
5441 
  def recv_updateItemHoldInventory(self, ):
5442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5443 
    if mtype == TMessageType.EXCEPTION:
5444 
      x = TApplicationException()
5445 
      x.read(self._iprot)
5446 
      self._iprot.readMessageEnd()
5447 
      raise x
5448 
    result = updateItemHoldInventory_result()
5449 
    result.read(self._iprot)
5450 
    self._iprot.readMessageEnd()
5451 
    return
5452 
 
9895 vikram.rag 5453 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5454 
    """
5455 
    Parameters:
5456 
     - item_id
5457 
     - vendor_id
5458 
     - nlc
5459 
    """
5460 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5461 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5462 
 
9895 vikram.rag 5463 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5464 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5465 
    args = updateNlcAtMarketplaces_args()
5466 
    args.item_id = item_id
5467 
    args.vendor_id = vendor_id
5468 
    args.nlc = nlc
5469 
    args.write(self._oprot)
5470 
    self._oprot.writeMessageEnd()
5471 
    self._oprot.trans.flush()
5472 
 
5473 
  def recv_updateNlcAtMarketplaces(self, ):
5474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5475 
    if mtype == TMessageType.EXCEPTION:
5476 
      x = TApplicationException()
5477 
      x.read(self._iprot)
5478 
      self._iprot.readMessageEnd()
5479 
      raise x
5480 
    result = updateNlcAtMarketplaces_result()
5481 
    result.read(self._iprot)
5482 
    self._iprot.readMessageEnd()
5483 
    return
5484 
 
5485 
 
5944 mandeep.dh 5486 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5487 
  def __init__(self, handler):
5488 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5489 
    self._processMap["addItem"] = Processor.process_addItem
5490 
    self._processMap["updateItem"] = Processor.process_updateItem
5491 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5492 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5493 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5494 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5495 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5496 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5497 
    self._processMap["getItem"] = Processor.process_getItem
5498 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5499 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5500 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5501 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5502 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5503 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5504 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5505 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5506 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5507 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5508 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5509 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5510 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5511 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5512 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5513 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5514 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5515 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5516 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5517 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5518 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5519 
    self._processMap["addCategory"] = Processor.process_addCategory
5520 
    self._processMap["getCategory"] = Processor.process_getCategory
5521 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5522 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5523 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5524 
    self._processMap["addTag"] = Processor.process_addTag
5525 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5526 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5527 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5528 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5529 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5530 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5531 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5532 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5533 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5534 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5535 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5536 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5537 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5538 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5539 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5540 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5541 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5542 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5543 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5544 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5545 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5546 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5547 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5548 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5549 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5550 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5551 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5552 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5553 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5554 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5555 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5556 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5557 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5558 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5559 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5560 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5561 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5562 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5563 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5564 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5565 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5566 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5567 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5568 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5569 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5570 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5571 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5572 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5573 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5574 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5575 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5576 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5577 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5578 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5579 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5580 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5581 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5582 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5583 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5584 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5585 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5586 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5587 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5588 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5589 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5590 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5591 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5592 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5593 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5594 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5595 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5596 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5597 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5598 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5599 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5600 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5601 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5602 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5603 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5604 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5605 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5606 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5607 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5608 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5609 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5610 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5611 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5612 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5613 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5614 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5615 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5616 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5617 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5618 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5619 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5620 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5621 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5622 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5623 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5624 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5625 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5626 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5627 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 5628 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 5629 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5630 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 5631 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 5632 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
5944 mandeep.dh 5633 
 
5634 
  def process(self, iprot, oprot):
5635 
    (name, type, seqid) = iprot.readMessageBegin()
5636 
    if name not in self._processMap:
5637 
      iprot.skip(TType.STRUCT)
5638 
      iprot.readMessageEnd()
5639 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5640 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5641 
      x.write(oprot)
5642 
      oprot.writeMessageEnd()
5643 
      oprot.trans.flush()
5644 
      return
5645 
    else:
5646 
      self._processMap[name](self, seqid, iprot, oprot)
5647 
    return True
5648 
 
5649 
  def process_addItem(self, seqid, iprot, oprot):
5650 
    args = addItem_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = addItem_result()
5654 
    try:
5655 
      result.success = self._handler.addItem(args.item)
5656 
    except CatalogServiceException, cex:
5657 
      result.cex = cex
5658 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
5663 
  def process_updateItem(self, seqid, iprot, oprot):
5664 
    args = updateItem_args()
5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
5667 
    result = updateItem_result()
5668 
    try:
5669 
      result.success = self._handler.updateItem(args.item)
5670 
    except CatalogServiceException, cex:
5671 
      result.cex = cex
5672 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
5676 
 
5677 
  def process_isActive(self, seqid, iprot, oprot):
5678 
    args = isActive_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = isActive_result()
5682 
    try:
5683 
      result.success = self._handler.isActive(args.itemId)
5684 
    except CatalogServiceException, isex:
5685 
      result.isex = isex
5686 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
7438 amit.gupta 5691 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5692 
    args = getItemsStatus_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = getItemsStatus_result()
5696 
    try:
5697 
      result.success = self._handler.getItemsStatus(args.itemIds)
5698 
    except CatalogServiceException, isex:
5699 
      result.isex = isex
5700 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
5944 mandeep.dh 5705 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5706 
    args = getItemStatusDescription_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = getItemStatusDescription_result()
5710 
    try:
5711 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5712 
    except CatalogServiceException, isex:
5713 
      result.isex = isex
5714 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
5718 
 
5719 
  def process_startItemOn(self, seqid, iprot, oprot):
5720 
    args = startItemOn_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = startItemOn_result()
5724 
    try:
5725 
      self._handler.startItemOn(args.item_id, args.timestamp)
5726 
    except CatalogServiceException, cex:
5727 
      result.cex = cex
5728 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
5733 
  def process_retireItemOn(self, seqid, iprot, oprot):
5734 
    args = retireItemOn_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = retireItemOn_result()
5738 
    try:
5739 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5740 
    except CatalogServiceException, cex:
5741 
      result.cex = cex
5742 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5743 
    result.write(oprot)
5744 
    oprot.writeMessageEnd()
5745 
    oprot.trans.flush()
5746 
 
5747 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5748 
    args = changeItemStatus_args()
5749 
    args.read(iprot)
5750 
    iprot.readMessageEnd()
5751 
    result = changeItemStatus_result()
5752 
    try:
5753 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5754 
    except CatalogServiceException, cex:
5755 
      result.cex = cex
5756 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5757 
    result.write(oprot)
5758 
    oprot.writeMessageEnd()
5759 
    oprot.trans.flush()
5760 
 
5761 
  def process_getItem(self, seqid, iprot, oprot):
5762 
    args = getItem_args()
5763 
    args.read(iprot)
5764 
    iprot.readMessageEnd()
5765 
    result = getItem_result()
5766 
    try:
5767 
      result.success = self._handler.getItem(args.item_id)
5768 
    except CatalogServiceException, cex:
5769 
      result.cex = cex
5770 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5771 
    result.write(oprot)
5772 
    oprot.writeMessageEnd()
5773 
    oprot.trans.flush()
5774 
 
5775 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5776 
    args = getItemsByCatalogId_args()
5777 
    args.read(iprot)
5778 
    iprot.readMessageEnd()
5779 
    result = getItemsByCatalogId_result()
5780 
    try:
5781 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5782 
    except CatalogServiceException, cex:
5783 
      result.cex = cex
5784 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5785 
    result.write(oprot)
5786 
    oprot.writeMessageEnd()
5787 
    oprot.trans.flush()
5788 
 
5789 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5790 
    args = getValidItemsByCatalogId_args()
5791 
    args.read(iprot)
5792 
    iprot.readMessageEnd()
5793 
    result = getValidItemsByCatalogId_result()
5794 
    try:
5795 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5796 
    except CatalogServiceException, cex:
5797 
      result.cex = cex
5798 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5799 
    result.write(oprot)
5800 
    oprot.writeMessageEnd()
5801 
    oprot.trans.flush()
5802 
 
5803 
  def process_getAllItems(self, seqid, iprot, oprot):
5804 
    args = getAllItems_args()
5805 
    args.read(iprot)
5806 
    iprot.readMessageEnd()
5807 
    result = getAllItems_result()
5808 
    try:
5809 
      result.success = self._handler.getAllItems(args.isActive)
5810 
    except CatalogServiceException, cex:
5811 
      result.cex = cex
5812 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5813 
    result.write(oprot)
5814 
    oprot.writeMessageEnd()
5815 
    oprot.trans.flush()
5816 
 
5817 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5818 
    args = getAllItemsByStatus_args()
5819 
    args.read(iprot)
5820 
    iprot.readMessageEnd()
5821 
    result = getAllItemsByStatus_result()
5822 
    try:
5823 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5824 
    except CatalogServiceException, cex:
5825 
      result.cex = cex
5826 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5827 
    result.write(oprot)
5828 
    oprot.writeMessageEnd()
5829 
    oprot.trans.flush()
5830 
 
5831 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5832 
    args = markItemAsContentComplete_args()
5833 
    args.read(iprot)
5834 
    iprot.readMessageEnd()
5835 
    result = markItemAsContentComplete_result()
5836 
    try:
9253 rajveer 5837 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5838 
    except CatalogServiceException, cex:
5839 
      result.cex = cex
5840 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5841 
    result.write(oprot)
5842 
    oprot.writeMessageEnd()
5843 
    oprot.trans.flush()
5844 
 
5845 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5846 
    args = getAllItemsInRange_args()
5847 
    args.read(iprot)
5848 
    iprot.readMessageEnd()
5849 
    result = getAllItemsInRange_result()
5850 
    try:
5851 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5852 
    except CatalogServiceException, cex:
5853 
      result.cex = cex
5854 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5855 
    result.write(oprot)
5856 
    oprot.writeMessageEnd()
5857 
    oprot.trans.flush()
5858 
 
5859 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5860 
    args = getAllItemsByStatusInRange_args()
5861 
    args.read(iprot)
5862 
    iprot.readMessageEnd()
5863 
    result = getAllItemsByStatusInRange_result()
5864 
    try:
5865 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5866 
    except CatalogServiceException, cex:
5867 
      result.cex = cex
5868 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
5872 
 
5873 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5874 
    args = getItemCountByStatus_args()
5875 
    args.read(iprot)
5876 
    iprot.readMessageEnd()
5877 
    result = getItemCountByStatus_result()
5878 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5879 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
5884 
  def process_getBestSellers(self, seqid, iprot, oprot):
5885 
    args = getBestSellers_args()
5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
5888 
    result = getBestSellers_result()
5889 
    try:
5890 
      result.success = self._handler.getBestSellers()
5891 
    except CatalogServiceException, isex:
5892 
      result.isex = isex
5893 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5894 
    result.write(oprot)
5895 
    oprot.writeMessageEnd()
5896 
    oprot.trans.flush()
5897 
 
5898 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5899 
    args = getBestSellersCatalogIds_args()
5900 
    args.read(iprot)
5901 
    iprot.readMessageEnd()
5902 
    result = getBestSellersCatalogIds_result()
5903 
    try:
5904 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5905 
    except CatalogServiceException, cex:
5906 
      result.cex = cex
5907 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5908 
    result.write(oprot)
5909 
    oprot.writeMessageEnd()
5910 
    oprot.trans.flush()
5911 
 
5912 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5913 
    args = getBestSellersCount_args()
5914 
    args.read(iprot)
5915 
    iprot.readMessageEnd()
5916 
    result = getBestSellersCount_result()
5917 
    try:
5918 
      result.success = self._handler.getBestSellersCount()
5919 
    except CatalogServiceException, cex:
5920 
      result.cex = cex
5921 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5922 
    result.write(oprot)
5923 
    oprot.writeMessageEnd()
5924 
    oprot.trans.flush()
5925 
 
5926 
  def process_getBestDeals(self, seqid, iprot, oprot):
5927 
    args = getBestDeals_args()
5928 
    args.read(iprot)
5929 
    iprot.readMessageEnd()
5930 
    result = getBestDeals_result()
5931 
    try:
5932 
      result.success = self._handler.getBestDeals()
5933 
    except CatalogServiceException, isex:
5934 
      result.isex = isex
5935 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5936 
    result.write(oprot)
5937 
    oprot.writeMessageEnd()
5938 
    oprot.trans.flush()
5939 
 
5940 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5941 
    args = getBestDealsCatalogIds_args()
5942 
    args.read(iprot)
5943 
    iprot.readMessageEnd()
5944 
    result = getBestDealsCatalogIds_result()
5945 
    try:
5946 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5947 
    except CatalogServiceException, cex:
5948 
      result.cex = cex
5949 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5950 
    result.write(oprot)
5951 
    oprot.writeMessageEnd()
5952 
    oprot.trans.flush()
5953 
 
5954 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5955 
    args = getBestDealsCount_args()
5956 
    args.read(iprot)
5957 
    iprot.readMessageEnd()
5958 
    result = getBestDealsCount_result()
5959 
    try:
5960 
      result.success = self._handler.getBestDealsCount()
5961 
    except CatalogServiceException, cex:
5962 
      result.cex = cex
5963 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5964 
    result.write(oprot)
5965 
    oprot.writeMessageEnd()
5966 
    oprot.trans.flush()
5967 
 
5968 
  def process_getComingSoon(self, seqid, iprot, oprot):
5969 
    args = getComingSoon_args()
5970 
    args.read(iprot)
5971 
    iprot.readMessageEnd()
5972 
    result = getComingSoon_result()
5973 
    try:
5974 
      result.success = self._handler.getComingSoon()
5975 
    except CatalogServiceException, isex:
5976 
      result.isex = isex
5977 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5978 
    result.write(oprot)
5979 
    oprot.writeMessageEnd()
5980 
    oprot.trans.flush()
5981 
 
5982 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5983 
    args = getComingSoonCatalogIds_args()
5984 
    args.read(iprot)
5985 
    iprot.readMessageEnd()
5986 
    result = getComingSoonCatalogIds_result()
5987 
    try:
5988 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5989 
    except CatalogServiceException, cex:
5990 
      result.cex = cex
5991 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5992 
    result.write(oprot)
5993 
    oprot.writeMessageEnd()
5994 
    oprot.trans.flush()
5995 
 
5996 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5997 
    args = getComingSoonCount_args()
5998 
    args.read(iprot)
5999 
    iprot.readMessageEnd()
6000 
    result = getComingSoonCount_result()
6001 
    try:
6002 
      result.success = self._handler.getComingSoonCount()
6003 
    except CatalogServiceException, cex:
6004 
      result.cex = cex
6005 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6006 
    result.write(oprot)
6007 
    oprot.writeMessageEnd()
6008 
    oprot.trans.flush()
6009 
 
6010 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6011 
    args = getLatestArrivals_args()
6012 
    args.read(iprot)
6013 
    iprot.readMessageEnd()
6014 
    result = getLatestArrivals_result()
6015 
    try:
6016 
      result.success = self._handler.getLatestArrivals()
6017 
    except CatalogServiceException, isex:
6018 
      result.isex = isex
6019 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6020 
    result.write(oprot)
6021 
    oprot.writeMessageEnd()
6022 
    oprot.trans.flush()
6023 
 
6024 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6025 
    args = getLatestArrivalsCatalogIds_args()
6026 
    args.read(iprot)
6027 
    iprot.readMessageEnd()
6028 
    result = getLatestArrivalsCatalogIds_result()
6029 
    try:
6030 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6031 
    except CatalogServiceException, cex:
6032 
      result.cex = cex
6033 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6034 
    result.write(oprot)
6035 
    oprot.writeMessageEnd()
6036 
    oprot.trans.flush()
6037 
 
6038 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6039 
    args = getLatestArrivalsCount_args()
6040 
    args.read(iprot)
6041 
    iprot.readMessageEnd()
6042 
    result = getLatestArrivalsCount_result()
6043 
    try:
6044 
      result.success = self._handler.getLatestArrivalsCount()
6045 
    except CatalogServiceException, cex:
6046 
      result.cex = cex
6047 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6048 
    result.write(oprot)
6049 
    oprot.writeMessageEnd()
6050 
    oprot.trans.flush()
6051 
 
6052 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6053 
    args = generateNewEntityID_args()
6054 
    args.read(iprot)
6055 
    iprot.readMessageEnd()
6056 
    result = generateNewEntityID_result()
6057 
    result.success = self._handler.generateNewEntityID()
6058 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6059 
    result.write(oprot)
6060 
    oprot.writeMessageEnd()
6061 
    oprot.trans.flush()
6062 
 
6063 
  def process_addCategory(self, seqid, iprot, oprot):
6064 
    args = addCategory_args()
6065 
    args.read(iprot)
6066 
    iprot.readMessageEnd()
6067 
    result = addCategory_result()
6068 
    result.success = self._handler.addCategory(args.category)
6069 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6070 
    result.write(oprot)
6071 
    oprot.writeMessageEnd()
6072 
    oprot.trans.flush()
6073 
 
6074 
  def process_getCategory(self, seqid, iprot, oprot):
6075 
    args = getCategory_args()
6076 
    args.read(iprot)
6077 
    iprot.readMessageEnd()
6078 
    result = getCategory_result()
6079 
    result.success = self._handler.getCategory(args.id)
6080 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6081 
    result.write(oprot)
6082 
    oprot.writeMessageEnd()
6083 
    oprot.trans.flush()
6084 
 
6085 
  def process_getAllCategories(self, seqid, iprot, oprot):
6086 
    args = getAllCategories_args()
6087 
    args.read(iprot)
6088 
    iprot.readMessageEnd()
6089 
    result = getAllCategories_result()
6090 
    result.success = self._handler.getAllCategories()
6091 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6092 
    result.write(oprot)
6093 
    oprot.writeMessageEnd()
6094 
    oprot.trans.flush()
6095 
 
6096 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6097 
    args = getAllSimilarItems_args()
6098 
    args.read(iprot)
6099 
    iprot.readMessageEnd()
6100 
    result = getAllSimilarItems_result()
6101 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6102 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6103 
    result.write(oprot)
6104 
    oprot.writeMessageEnd()
6105 
    oprot.trans.flush()
6106 
 
6107 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6108 
    args = addSimilarItem_args()
6109 
    args.read(iprot)
6110 
    iprot.readMessageEnd()
6111 
    result = addSimilarItem_result()
6112 
    try:
6113 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6114 
    except CatalogServiceException, cex:
6115 
      result.cex = cex
6116 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6117 
    result.write(oprot)
6118 
    oprot.writeMessageEnd()
6119 
    oprot.trans.flush()
6120 
 
6512 kshitij.so 6121 
  def process_addTag(self, seqid, iprot, oprot):
6122 
    args = addTag_args()
6123 
    args.read(iprot)
6124 
    iprot.readMessageEnd()
6125 
    result = addTag_result()
6126 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6127 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6128 
    result.write(oprot)
6129 
    oprot.writeMessageEnd()
6130 
    oprot.trans.flush()
6131 
 
6132 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6133 
    args = deleteEntityTag_args()
6134 
    args.read(iprot)
6135 
    iprot.readMessageEnd()
6136 
    result = deleteEntityTag_result()
6137 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6138 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6139 
    result.write(oprot)
6140 
    oprot.writeMessageEnd()
6141 
    oprot.trans.flush()
6142 
 
6143 
  def process_deleteTag(self, seqid, iprot, oprot):
6144 
    args = deleteTag_args()
6145 
    args.read(iprot)
6146 
    iprot.readMessageEnd()
6147 
    result = deleteTag_result()
6148 
    result.success = self._handler.deleteTag(args.displayName)
6149 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6150 
    result.write(oprot)
6151 
    oprot.writeMessageEnd()
6152 
    oprot.trans.flush()
6153 
 
6154 
  def process_getAllTags(self, seqid, iprot, oprot):
6155 
    args = getAllTags_args()
6156 
    args.read(iprot)
6157 
    iprot.readMessageEnd()
6158 
    result = getAllTags_result()
6159 
    result.success = self._handler.getAllTags()
6160 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6161 
    result.write(oprot)
6162 
    oprot.writeMessageEnd()
6163 
    oprot.trans.flush()
6164 
 
6165 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6166 
    args = getAllEntitiesByTagName_args()
6167 
    args.read(iprot)
6168 
    iprot.readMessageEnd()
6169 
    result = getAllEntitiesByTagName_result()
6170 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6171 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6172 
    result.write(oprot)
6173 
    oprot.writeMessageEnd()
6174 
    oprot.trans.flush()
6175 
 
6845 amit.gupta 6176 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6177 
    args = getAllEntityTags_args()
6178 
    args.read(iprot)
6179 
    iprot.readMessageEnd()
6180 
    result = getAllEntityTags_result()
6181 
    result.success = self._handler.getAllEntityTags()
6182 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
6186 
 
6850 kshitij.so 6187 
  def process_addBanner(self, seqid, iprot, oprot):
6188 
    args = addBanner_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = addBanner_result()
8590 kshitij.so 6192 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6193 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6194 
    result.write(oprot)
6195 
    oprot.writeMessageEnd()
6196 
    oprot.trans.flush()
6197 
 
8579 kshitij.so 6198 
  def process_updateBanner(self, seqid, iprot, oprot):
6199 
    args = updateBanner_args()
6200 
    args.read(iprot)
6201 
    iprot.readMessageEnd()
6202 
    result = updateBanner_result()
6203 
    result.success = self._handler.updateBanner(args.banner)
6204 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
6208 
 
6850 kshitij.so 6209 
  def process_getAllBanners(self, seqid, iprot, oprot):
6210 
    args = getAllBanners_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = getAllBanners_result()
6214 
    result.success = self._handler.getAllBanners()
6215 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6216 
    result.write(oprot)
6217 
    oprot.writeMessageEnd()
6218 
    oprot.trans.flush()
6219 
 
6220 
  def process_deleteBanner(self, seqid, iprot, oprot):
6221 
    args = deleteBanner_args()
6222 
    args.read(iprot)
6223 
    iprot.readMessageEnd()
6224 
    result = deleteBanner_result()
9155 kshitij.so 6225 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6226 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
6230 
 
6231 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6232 
    args = getBannerDetails_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = getBannerDetails_result()
9155 kshitij.so 6236 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6237 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6238 
    result.write(oprot)
6239 
    oprot.writeMessageEnd()
6240 
    oprot.trans.flush()
6241 
 
6242 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6243 
    args = getActiveBanners_args()
6244 
    args.read(iprot)
6245 
    iprot.readMessageEnd()
6246 
    result = getActiveBanners_result()
6247 
    result.success = self._handler.getActiveBanners()
6248 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
6252 
 
6849 kshitij.so 6253 
  def process_addBannerMap(self, seqid, iprot, oprot):
6254 
    args = addBannerMap_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = addBannerMap_result()
8579 kshitij.so 6258 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6259 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6260 
    result.write(oprot)
6261 
    oprot.writeMessageEnd()
6262 
    oprot.trans.flush()
6263 
 
8579 kshitij.so 6264 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6265 
    args = updateBannerMap_args()
6266 
    args.read(iprot)
6267 
    iprot.readMessageEnd()
6268 
    result = updateBannerMap_result()
6269 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6270 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6271 
    result.write(oprot)
6272 
    oprot.writeMessageEnd()
6273 
    oprot.trans.flush()
6274 
 
6849 kshitij.so 6275 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6276 
    args = deleteBannerMap_args()
6277 
    args.read(iprot)
6278 
    iprot.readMessageEnd()
6279 
    result = deleteBannerMap_result()
6280 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6281 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6282 
    result.write(oprot)
6283 
    oprot.writeMessageEnd()
6284 
    oprot.trans.flush()
6285 
 
6286 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6287 
    args = getBannerMapDetails_args()
6288 
    args.read(iprot)
6289 
    iprot.readMessageEnd()
6290 
    result = getBannerMapDetails_result()
9155 kshitij.so 6291 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6292 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6293 
    result.write(oprot)
6294 
    oprot.writeMessageEnd()
6295 
    oprot.trans.flush()
6296 
 
8579 kshitij.so 6297 
  def process_addBannerUri(self, seqid, iprot, oprot):
6298 
    args = addBannerUri_args()
6299 
    args.read(iprot)
6300 
    iprot.readMessageEnd()
6301 
    result = addBannerUri_result()
6302 
    self._handler.addBannerUri(args.bannerUriMappings)
6303 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6304 
    result.write(oprot)
6305 
    oprot.writeMessageEnd()
6306 
    oprot.trans.flush()
6307 
 
6308 
  def process_getUriMapping(self, seqid, iprot, oprot):
6309 
    args = getUriMapping_args()
6310 
    args.read(iprot)
6311 
    iprot.readMessageEnd()
6312 
    result = getUriMapping_result()
9155 kshitij.so 6313 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6314 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6315 
    result.write(oprot)
6316 
    oprot.writeMessageEnd()
6317 
    oprot.trans.flush()
6318 
 
6319 
  def process_addCampaign(self, seqid, iprot, oprot):
6320 
    args = addCampaign_args()
6321 
    args.read(iprot)
6322 
    iprot.readMessageEnd()
6323 
    result = addCampaign_result()
6324 
    self._handler.addCampaign(args.campaign)
6325 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6326 
    result.write(oprot)
6327 
    oprot.writeMessageEnd()
6328 
    oprot.trans.flush()
6329 
 
6330 
  def process_getCampaigns(self, seqid, iprot, oprot):
6331 
    args = getCampaigns_args()
6332 
    args.read(iprot)
6333 
    iprot.readMessageEnd()
6334 
    result = getCampaigns_result()
6335 
    result.success = self._handler.getCampaigns(args.campaignName)
6336 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6337 
    result.write(oprot)
6338 
    oprot.writeMessageEnd()
6339 
    oprot.trans.flush()
6340 
 
6341 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6342 
    args = deleteCampaign_args()
6343 
    args.read(iprot)
6344 
    iprot.readMessageEnd()
6345 
    result = deleteCampaign_result()
6346 
    self._handler.deleteCampaign(args.campaignId)
6347 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6348 
    result.write(oprot)
6349 
    oprot.writeMessageEnd()
6350 
    oprot.trans.flush()
6351 
 
6352 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6353 
    args = getAllCampaigns_args()
6354 
    args.read(iprot)
6355 
    iprot.readMessageEnd()
6356 
    result = getAllCampaigns_result()
6357 
    result.success = self._handler.getAllCampaigns()
6358 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
6362 
 
9155 kshitij.so 6363 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6364 
    args = getActiveBannersForMobileSite_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = getActiveBannersForMobileSite_result()
6368 
    result.success = self._handler.getActiveBannersForMobileSite()
6369 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6370 
    result.write(oprot)
6371 
    oprot.writeMessageEnd()
6372 
    oprot.trans.flush()
6373 
 
5944 mandeep.dh 6374 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6375 
    args = deleteSimilarItem_args()
6376 
    args.read(iprot)
6377 
    iprot.readMessageEnd()
6378 
    result = deleteSimilarItem_result()
6379 
    try:
6380 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6381 
    except CatalogServiceException, cex:
6382 
      result.cex = cex
6383 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6384 
    result.write(oprot)
6385 
    oprot.writeMessageEnd()
6386 
    oprot.trans.flush()
6387 
 
6388 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6389 
    args = checkSimilarItem_args()
6390 
    args.read(iprot)
6391 
    iprot.readMessageEnd()
6392 
    result = checkSimilarItem_result()
6393 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6394 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6395 
    result.write(oprot)
6396 
    oprot.writeMessageEnd()
6397 
    oprot.trans.flush()
6398 
 
6399 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6400 
    args = validateRiskyStatus_args()
6401 
    args.read(iprot)
6402 
    iprot.readMessageEnd()
6403 
    result = validateRiskyStatus_result()
6404 
    self._handler.validateRiskyStatus(args.itemId)
6405 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6406 
    result.write(oprot)
6407 
    oprot.writeMessageEnd()
6408 
    oprot.trans.flush()
6409 
 
6410 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6411 
    args = changeItemRiskyFlag_args()
6412 
    args.read(iprot)
6413 
    iprot.readMessageEnd()
6414 
    result = changeItemRiskyFlag_result()
6415 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6416 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6417 
    result.write(oprot)
6418 
    oprot.writeMessageEnd()
6419 
    oprot.trans.flush()
6420 
 
6421 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6422 
    args = getItemsByRiskyFlag_args()
6423 
    args.read(iprot)
6424 
    iprot.readMessageEnd()
6425 
    result = getItemsByRiskyFlag_result()
6426 
    result.success = self._handler.getItemsByRiskyFlag()
6427 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6428 
    result.write(oprot)
6429 
    oprot.writeMessageEnd()
6430 
    oprot.trans.flush()
6431 
 
6432 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6433 
    args = getItemsForMasterSheet_args()
6434 
    args.read(iprot)
6435 
    iprot.readMessageEnd()
6436 
    result = getItemsForMasterSheet_result()
6437 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6438 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
6442 
 
6443 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6444 
    args = getSimilarItemsCatalogIds_args()
6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
6447 
    result = getSimilarItemsCatalogIds_result()
6448 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6449 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6450 
    result.write(oprot)
6451 
    oprot.writeMessageEnd()
6452 
    oprot.trans.flush()
6453 
 
6454 
  def process_addProductNotification(self, seqid, iprot, oprot):
6455 
    args = addProductNotification_args()
6456 
    args.read(iprot)
6457 
    iprot.readMessageEnd()
6458 
    result = addProductNotification_result()
6459 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6460 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6461 
    result.write(oprot)
6462 
    oprot.writeMessageEnd()
6463 
    oprot.trans.flush()
6464 
 
6465 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6466 
    args = sendProductNotifications_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = sendProductNotifications_result()
6470 
    result.success = self._handler.sendProductNotifications()
6471 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6472 
    result.write(oprot)
6473 
    oprot.writeMessageEnd()
6474 
    oprot.trans.flush()
6475 
 
6476 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6477 
    args = getAllBrandsByCategory_args()
6478 
    args.read(iprot)
6479 
    iprot.readMessageEnd()
6480 
    result = getAllBrandsByCategory_result()
6481 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6482 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6483 
    result.write(oprot)
6484 
    oprot.writeMessageEnd()
6485 
    oprot.trans.flush()
6486 
 
6487 
  def process_getAllBrands(self, seqid, iprot, oprot):
6488 
    args = getAllBrands_args()
6489 
    args.read(iprot)
6490 
    iprot.readMessageEnd()
6491 
    result = getAllBrands_result()
6492 
    result.success = self._handler.getAllBrands()
6493 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6494 
    result.write(oprot)
6495 
    oprot.writeMessageEnd()
6496 
    oprot.trans.flush()
6497 
 
6498 
  def process_getAllSources(self, seqid, iprot, oprot):
6499 
    args = getAllSources_args()
6500 
    args.read(iprot)
6501 
    iprot.readMessageEnd()
6502 
    result = getAllSources_result()
6503 
    result.success = self._handler.getAllSources()
6504 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
6509 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6510 
    args = getItemPricingBySource_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = getItemPricingBySource_result()
6514 
    try:
6515 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6516 
    except CatalogServiceException, cex:
6517 
      result.cex = cex
6518 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6524 
    args = addSourceItemPricing_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = addSourceItemPricing_result()
6528 
    try:
6529 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6530 
    except CatalogServiceException, cex:
6531 
      result.cex = cex
6532 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6533 
    result.write(oprot)
6534 
    oprot.writeMessageEnd()
6535 
    oprot.trans.flush()
6536 
 
6537 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6538 
    args = getAllSourcePricing_args()
6539 
    args.read(iprot)
6540 
    iprot.readMessageEnd()
6541 
    result = getAllSourcePricing_result()
6542 
    try:
6543 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6544 
    except CatalogServiceException, cex:
6545 
      result.cex = cex
6546 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6551 
  def process_getItemForSource(self, seqid, iprot, oprot):
6552 
    args = getItemForSource_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = getItemForSource_result()
6556 
    try:
6557 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6558 
    except CatalogServiceException, cex:
6559 
      result.cex = cex
6560 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
6564 
 
6565 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6566 
    args = searchItemsInRange_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = searchItemsInRange_result()
6570 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6571 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
6576 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6577 
    args = getSearchResultCount_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getSearchResultCount_result()
6581 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6582 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
6587 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6588 
    args = getProductNotifications_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getProductNotifications_result()
6592 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6593 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6597 
 
6598 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6599 
    args = getProductNotificationRequestCount_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6603 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6604 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
6608 
 
6609 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6610 
    args = addAuthorizationLog_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = addAuthorizationLog_result()
6614 
    try:
6615 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6616 
    except CatalogServiceException, cex:
6617 
      result.cex = cex
6618 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
6623 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6624 
    args = addupdateVoucherForItem_args()
6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
6627 
    result = addupdateVoucherForItem_result()
6628 
    try:
6629 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6630 
    except CatalogServiceException, cex:
6631 
      result.cex = cex
6632 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6633 
    result.write(oprot)
6634 
    oprot.writeMessageEnd()
6635 
    oprot.trans.flush()
6636 
 
6637 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6638 
    args = deleteVoucherForItem_args()
6639 
    args.read(iprot)
6640 
    iprot.readMessageEnd()
6641 
    result = deleteVoucherForItem_result()
6642 
    try:
6643 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6644 
    except CatalogServiceException, cex:
6645 
      result.cex = cex
6646 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6647 
    result.write(oprot)
6648 
    oprot.writeMessageEnd()
6649 
    oprot.trans.flush()
6650 
 
6651 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6652 
    args = getVoucherAmount_args()
6653 
    args.read(iprot)
6654 
    iprot.readMessageEnd()
6655 
    result = getVoucherAmount_result()
6656 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6657 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6658 
    result.write(oprot)
6659 
    oprot.writeMessageEnd()
6660 
    oprot.trans.flush()
6661 
 
6662 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6663 
    args = getAllItemVouchers_args()
6664 
    args.read(iprot)
6665 
    iprot.readMessageEnd()
6666 
    result = getAllItemVouchers_result()
6667 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6668 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
6672 
 
6673 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6674 
    args = isValidCatalogItemId_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = isValidCatalogItemId_result()
6678 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6679 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6680 
    result.write(oprot)
6681 
    oprot.writeMessageEnd()
6682 
    oprot.trans.flush()
6683 
 
6039 amit.gupta 6684 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6685 
    args = getVatPercentageForItem_args()
6686 
    args.read(iprot)
6687 
    iprot.readMessageEnd()
6688 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6689 
    try:
6690 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6691 
    except CatalogServiceException, cex:
6692 
      result.cex = cex
6039 amit.gupta 6693 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6694 
    result.write(oprot)
6695 
    oprot.writeMessageEnd()
6696 
    oprot.trans.flush()
5944 mandeep.dh 6697 
 
6039 amit.gupta 6698 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6699 
    args = getVatAmountForItem_args()
6700 
    args.read(iprot)
6701 
    iprot.readMessageEnd()
6702 
    result = getVatAmountForItem_result()
6703 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6704 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6705 
    result.write(oprot)
6706 
    oprot.writeMessageEnd()
6707 
    oprot.trans.flush()
6708 
 
6531 vikram.rag 6709 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6710 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6711 
    args.read(iprot)
6712 
    iprot.readMessageEnd()
6713 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6714 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6715 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6716 
    result.write(oprot)
6717 
    oprot.writeMessageEnd()
6718 
    oprot.trans.flush()
6039 amit.gupta 6719 
 
6821 amar.kumar 6720 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6721 
    args = getAllAliveItems_args()
6722 
    args.read(iprot)
6723 
    iprot.readMessageEnd()
6724 
    result = getAllAliveItems_result()
6725 
    result.success = self._handler.getAllAliveItems()
6726 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6727 
    result.write(oprot)
6728 
    oprot.writeMessageEnd()
6729 
    oprot.trans.flush()
6730 
 
6805 anupam.sin 6731 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6732 
    args = getInsuranceAmount_args()
6733 
    args.read(iprot)
6734 
    iprot.readMessageEnd()
6735 
    result = getInsuranceAmount_result()
6921 anupam.sin 6736 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6737 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6738 
    result.write(oprot)
6739 
    oprot.writeMessageEnd()
6740 
    oprot.trans.flush()
6531 vikram.rag 6741 
 
6805 anupam.sin 6742 
  def process_getInsurer(self, seqid, iprot, oprot):
6743 
    args = getInsurer_args()
6744 
    args.read(iprot)
6745 
    iprot.readMessageEnd()
6746 
    result = getInsurer_result()
6747 
    result.success = self._handler.getInsurer(args.insurerId)
6748 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6749 
    result.write(oprot)
6750 
    oprot.writeMessageEnd()
6751 
    oprot.trans.flush()
6752 
 
6838 vikram.rag 6753 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6754 
    args = getAllInsurers_args()
6755 
    args.read(iprot)
6756 
    iprot.readMessageEnd()
6757 
    result = getAllInsurers_result()
6758 
    result.success = self._handler.getAllInsurers()
6759 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6760 
    result.write(oprot)
6761 
    oprot.writeMessageEnd()
6762 
    oprot.trans.flush()
6805 anupam.sin 6763 
 
6962 rajveer 6764 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6765 
    args = updateInsuranceDeclaredAmount_args()
6766 
    args.read(iprot)
6767 
    iprot.readMessageEnd()
6768 
    result = updateInsuranceDeclaredAmount_result()
6769 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6770 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6771 
    result.write(oprot)
6772 
    oprot.writeMessageEnd()
6773 
    oprot.trans.flush()
6838 vikram.rag 6774 
 
7190 amar.kumar 6775 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6776 
    args = getFreebieForItem_args()
6777 
    args.read(iprot)
6778 
    iprot.readMessageEnd()
6779 
    result = getFreebieForItem_result()
6780 
    result.success = self._handler.getFreebieForItem(args.itemId)
6781 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6782 
    result.write(oprot)
6783 
    oprot.writeMessageEnd()
6784 
    oprot.trans.flush()
6962 rajveer 6785 
 
7190 amar.kumar 6786 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6787 
    args = addOrUpdateFreebieForItem_args()
6788 
    args.read(iprot)
6789 
    iprot.readMessageEnd()
6790 
    result = addOrUpdateFreebieForItem_result()
6791 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6792 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6793 
    result.write(oprot)
6794 
    oprot.writeMessageEnd()
6795 
    oprot.trans.flush()
6796 
 
7272 amit.gupta 6797 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6798 
    args = addOrUpdateBrandInfo_args()
6799 
    args.read(iprot)
6800 
    iprot.readMessageEnd()
6801 
    result = addOrUpdateBrandInfo_result()
6802 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6803 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6804 
    result.write(oprot)
6805 
    oprot.writeMessageEnd()
6806 
    oprot.trans.flush()
6807 
 
6808 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6809 
    args = getBrandInfo_args()
6810 
    args.read(iprot)
6811 
    iprot.readMessageEnd()
6812 
    result = getBrandInfo_result()
6813 
    result.success = self._handler.getBrandInfo()
6814 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6815 
    result.write(oprot)
6816 
    oprot.writeMessageEnd()
6817 
    oprot.trans.flush()
6818 
 
7256 rajveer 6819 
  def process_getStorePricing(self, seqid, iprot, oprot):
6820 
    args = getStorePricing_args()
6821 
    args.read(iprot)
6822 
    iprot.readMessageEnd()
6823 
    result = getStorePricing_result()
6824 
    result.success = self._handler.getStorePricing(args.itemId)
6825 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6826 
    result.write(oprot)
6827 
    oprot.writeMessageEnd()
6828 
    oprot.trans.flush()
7190 amar.kumar 6829 
 
7306 rajveer 6830 
  def process_getStorePricings(self, seqid, iprot, oprot):
6831 
    args = getStorePricings_args()
6832 
    args.read(iprot)
6833 
    iprot.readMessageEnd()
6834 
    result = getStorePricings_result()
6835 
    result.success = self._handler.getStorePricings(args.itemIds)
6836 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6837 
    result.write(oprot)
6838 
    oprot.writeMessageEnd()
6839 
    oprot.trans.flush()
6840 
 
7265 rajveer 6841 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6842 
    args = updateStorePricing_args()
6843 
    args.read(iprot)
6844 
    iprot.readMessageEnd()
6845 
    result = updateStorePricing_result()
7382 rajveer 6846 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6847 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6848 
    result.write(oprot)
6849 
    oprot.writeMessageEnd()
6850 
    oprot.trans.flush()
7256 rajveer 6851 
 
7281 kshitij.so 6852 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6853 
    args = getAllAmazonListedItems_args()
6854 
    args.read(iprot)
6855 
    iprot.readMessageEnd()
6856 
    result = getAllAmazonListedItems_result()
6857 
    result.success = self._handler.getAllAmazonListedItems()
6858 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6859 
    result.write(oprot)
6860 
    oprot.writeMessageEnd()
6861 
    oprot.trans.flush()
7265 rajveer 6862 
 
8619 kshitij.so 6863 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6864 
    args = searchAmazonItems_args()
6865 
    args.read(iprot)
6866 
    iprot.readMessageEnd()
6867 
    result = searchAmazonItems_result()
6868 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6869 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6870 
    result.write(oprot)
6871 
    oprot.writeMessageEnd()
6872 
    oprot.trans.flush()
6873 
 
6874 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6875 
    args = getAmazonSearchResultCount_args()
6876 
    args.read(iprot)
6877 
    iprot.readMessageEnd()
6878 
    result = getAmazonSearchResultCount_result()
6879 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6880 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6881 
    result.write(oprot)
6882 
    oprot.writeMessageEnd()
6883 
    oprot.trans.flush()
6884 
 
6885 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6886 
    args = getCountForAmazonlistedItems_args()
6887 
    args.read(iprot)
6888 
    iprot.readMessageEnd()
6889 
    result = getCountForAmazonlistedItems_result()
6890 
    result.success = self._handler.getCountForAmazonlistedItems()
6891 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6892 
    result.write(oprot)
6893 
    oprot.writeMessageEnd()
6894 
    oprot.trans.flush()
6895 
 
7281 kshitij.so 6896 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6897 
    args = getAmazonItemDetails_args()
6898 
    args.read(iprot)
6899 
    iprot.readMessageEnd()
6900 
    result = getAmazonItemDetails_result()
6901 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6902 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6903 
    result.write(oprot)
6904 
    oprot.writeMessageEnd()
6905 
    oprot.trans.flush()
6906 
 
6907 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6908 
    args = updateAmazonItemDetails_args()
6909 
    args.read(iprot)
6910 
    iprot.readMessageEnd()
6911 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6912 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6913 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6914 
    result.write(oprot)
6915 
    oprot.writeMessageEnd()
6916 
    oprot.trans.flush()
6917 
 
6918 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6919 
    args = addAmazonItem_args()
6920 
    args.read(iprot)
6921 
    iprot.readMessageEnd()
6922 
    result = addAmazonItem_result()
6923 
    self._handler.addAmazonItem(args.amazonlisted)
6924 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6925 
    result.write(oprot)
6926 
    oprot.writeMessageEnd()
6927 
    oprot.trans.flush()
6928 
 
7291 vikram.rag 6929 
  def process_getAsinItems(self, seqid, iprot, oprot):
6930 
    args = getAsinItems_args()
6931 
    args.read(iprot)
6932 
    iprot.readMessageEnd()
6933 
    result = getAsinItems_result()
6934 
    result.success = self._handler.getAsinItems()
6935 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6936 
    result.write(oprot)
6937 
    oprot.writeMessageEnd()
6938 
    oprot.trans.flush()
7281 kshitij.so 6939 
 
7291 vikram.rag 6940 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6941 
    args = getAllFbaListedItems_args()
6942 
    args.read(iprot)
6943 
    iprot.readMessageEnd()
6944 
    result = getAllFbaListedItems_result()
6945 
    result.success = self._handler.getAllFbaListedItems()
6946 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6947 
    result.write(oprot)
6948 
    oprot.writeMessageEnd()
6949 
    oprot.trans.flush()
6950 
 
6951 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6952 
    args = getAllNonFbaListedItems_args()
6953 
    args.read(iprot)
6954 
    iprot.readMessageEnd()
6955 
    result = getAllNonFbaListedItems_result()
6956 
    result.success = self._handler.getAllNonFbaListedItems()
6957 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6958 
    result.write(oprot)
6959 
    oprot.writeMessageEnd()
6960 
    oprot.trans.flush()
6961 
 
7460 kshitij.so 6962 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6963 
    args = updateItemInventory_args()
6964 
    args.read(iprot)
6965 
    iprot.readMessageEnd()
6966 
    result = updateItemInventory_result()
6967 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6968 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6969 
    result.write(oprot)
6970 
    oprot.writeMessageEnd()
6971 
    oprot.trans.flush()
7291 vikram.rag 6972 
 
7770 kshitij.so 6973 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6974 
    args = updateTimestampForAmazonFeeds_args()
6975 
    args.read(iprot)
6976 
    iprot.readMessageEnd()
6977 
    result = updateTimestampForAmazonFeeds_result()
6978 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6979 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6980 
    result.write(oprot)
6981 
    oprot.writeMessageEnd()
6982 
    oprot.trans.flush()
7460 kshitij.so 6983 
 
7897 amar.kumar 6984 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6985 
    args = getAllParentCategories_args()
6986 
    args.read(iprot)
6987 
    iprot.readMessageEnd()
6988 
    result = getAllParentCategories_result()
6989 
    result.success = self._handler.getAllParentCategories()
6990 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6991 
    result.write(oprot)
6992 
    oprot.writeMessageEnd()
6993 
    oprot.trans.flush()
7770 kshitij.so 6994 
 
7977 kshitij.so 6995 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6996 
    args = addPageViewEvent_args()
6997 
    args.read(iprot)
6998 
    iprot.readMessageEnd()
6999 
    result = addPageViewEvent_result()
7000 
    self._handler.addPageViewEvent(args.pageViewEvents)
7001 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7002 
    result.write(oprot)
7003 
    oprot.writeMessageEnd()
7004 
    oprot.trans.flush()
7897 amar.kumar 7005 
 
7977 kshitij.so 7006 
  def process_addCartEvent(self, seqid, iprot, oprot):
7007 
    args = addCartEvent_args()
7008 
    args.read(iprot)
7009 
    iprot.readMessageEnd()
7010 
    result = addCartEvent_result()
7011 
    self._handler.addCartEvent(args.cartEvents)
7012 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7013 
    result.write(oprot)
7014 
    oprot.writeMessageEnd()
7015 
    oprot.trans.flush()
7016 
 
8182 amar.kumar 7017 
  def process_addEbayItem(self, seqid, iprot, oprot):
7018 
    args = addEbayItem_args()
7019 
    args.read(iprot)
7020 
    iprot.readMessageEnd()
7021 
    result = addEbayItem_result()
7022 
    self._handler.addEbayItem(args.ebayItem)
7023 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7024 
    result.write(oprot)
7025 
    oprot.writeMessageEnd()
7026 
    oprot.trans.flush()
7027 
 
7028 
  def process_getEbayItem(self, seqid, iprot, oprot):
7029 
    args = getEbayItem_args()
7030 
    args.read(iprot)
7031 
    iprot.readMessageEnd()
7032 
    result = getEbayItem_result()
7033 
    result.success = self._handler.getEbayItem(args.listingId)
7034 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
7039 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7040 
    args = updateEbayItem_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = updateEbayItem_result()
7044 
    self._handler.updateEbayItem(args.ebayItem)
7045 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
8139 kshitij.so 7050 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7051 
    args = getAmazonListedItems_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = getAmazonListedItems_result()
7055 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7056 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7057 
    result.write(oprot)
7058 
    oprot.writeMessageEnd()
7059 
    oprot.trans.flush()
7977 kshitij.so 7060 
 
8168 kshitij.so 7061 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7062 
    args = updateAmazonAttributesInBulk_args()
7063 
    args.read(iprot)
7064 
    iprot.readMessageEnd()
7065 
    result = updateAmazonAttributesInBulk_result()
7066 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7067 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7068 
    result.write(oprot)
7069 
    oprot.writeMessageEnd()
7070 
    oprot.trans.flush()
8139 kshitij.so 7071 
 
8379 vikram.rag 7072 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7073 
    args = getAllItemstoListOnFba_args()
7074 
    args.read(iprot)
7075 
    iprot.readMessageEnd()
7076 
    result = getAllItemstoListOnFba_result()
7077 
    result.success = self._handler.getAllItemstoListOnFba()
7078 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7079 
    result.write(oprot)
7080 
    oprot.writeMessageEnd()
7081 
    oprot.trans.flush()
8168 kshitij.so 7082 
 
8379 vikram.rag 7083 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7084 
    args = getAllItemstoListOnNonFba_args()
7085 
    args.read(iprot)
7086 
    iprot.readMessageEnd()
7087 
    result = getAllItemstoListOnNonFba_result()
7088 
    result.success = self._handler.getAllItemstoListOnNonFba()
7089 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7090 
    result.write(oprot)
7091 
    oprot.writeMessageEnd()
7092 
    oprot.trans.flush()
7093 
 
8619 kshitij.so 7094 
  def process_updateAsin(self, seqid, iprot, oprot):
7095 
    args = updateAsin_args()
7096 
    args.read(iprot)
7097 
    iprot.readMessageEnd()
7098 
    result = updateAsin_result()
7099 
    self._handler.updateAsin(args.item)
7100 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7101 
    result.write(oprot)
7102 
    oprot.writeMessageEnd()
7103 
    oprot.trans.flush()
8616 vikram.rag 7104 
 
8739 vikram.rag 7105 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7106 
    args = addOrUpdateSnapdealItem_args()
7107 
    args.read(iprot)
7108 
    iprot.readMessageEnd()
7109 
    result = addOrUpdateSnapdealItem_result()
7110 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7111 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7112 
    result.write(oprot)
7113 
    oprot.writeMessageEnd()
7114 
    oprot.trans.flush()
8619 kshitij.so 7115 
 
8739 vikram.rag 7116 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7117 
    args = getSnapdealItem_args()
7118 
    args.read(iprot)
7119 
    iprot.readMessageEnd()
7120 
    result = getSnapdealItem_result()
7121 
    result.success = self._handler.getSnapdealItem(args.item_id)
7122 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7123 
    result.write(oprot)
7124 
    oprot.writeMessageEnd()
7125 
    oprot.trans.flush()
7126 
 
9242 kshitij.so 7127 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7128 
    args = getSnapdealItemDetails_args()
7129 
    args.read(iprot)
7130 
    iprot.readMessageEnd()
7131 
    result = getSnapdealItemDetails_result()
7132 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7133 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7134 
    result.write(oprot)
7135 
    oprot.writeMessageEnd()
7136 
    oprot.trans.flush()
7137 
 
8739 vikram.rag 7138 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7139 
    args = getAllSnapdealItems_args()
7140 
    args.read(iprot)
7141 
    iprot.readMessageEnd()
7142 
    result = getAllSnapdealItems_result()
7143 
    result.success = self._handler.getAllSnapdealItems()
7144 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7145 
    result.write(oprot)
7146 
    oprot.writeMessageEnd()
7147 
    oprot.trans.flush()
7148 
 
9242 kshitij.so 7149 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7150 
    args = getSnapdealItems_args()
7151 
    args.read(iprot)
7152 
    iprot.readMessageEnd()
7153 
    result = getSnapdealItems_result()
7154 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7155 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7156 
    result.write(oprot)
7157 
    oprot.writeMessageEnd()
7158 
    oprot.trans.flush()
8739 vikram.rag 7159 
 
9242 kshitij.so 7160 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7161 
    args = searchSnapdealItems_args()
7162 
    args.read(iprot)
7163 
    iprot.readMessageEnd()
7164 
    result = searchSnapdealItems_result()
7165 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7166 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7167 
    result.write(oprot)
7168 
    oprot.writeMessageEnd()
7169 
    oprot.trans.flush()
7170 
 
7171 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7172 
    args = getCountForSnapdealItems_args()
7173 
    args.read(iprot)
7174 
    iprot.readMessageEnd()
7175 
    result = getCountForSnapdealItems_result()
7176 
    result.success = self._handler.getCountForSnapdealItems()
7177 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7178 
    result.write(oprot)
7179 
    oprot.writeMessageEnd()
7180 
    oprot.trans.flush()
7181 
 
7182 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7183 
    args = getSnapdealSearchResultCount_args()
7184 
    args.read(iprot)
7185 
    iprot.readMessageEnd()
7186 
    result = getSnapdealSearchResultCount_result()
7187 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7188 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
9299 kshitij.so 7193 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7194 
    args = getPrefferedInsurerForItem_args()
7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
7197 
    result = getPrefferedInsurerForItem_result()
7198 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7199 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7200 
    result.write(oprot)
7201 
    oprot.writeMessageEnd()
7202 
    oprot.trans.flush()
9242 kshitij.so 7203 
 
9456 vikram.rag 7204 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7205 
    args = getSnapdealItembySkuAtSnapdeal_args()
7206 
    args.read(iprot)
7207 
    iprot.readMessageEnd()
7208 
    result = getSnapdealItembySkuAtSnapdeal_result()
7209 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7210 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7211 
    result.write(oprot)
7212 
    oprot.writeMessageEnd()
7213 
    oprot.trans.flush()
9299 kshitij.so 7214 
 
9621 manish.sha 7215 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7216 
    args = getProductFeedSubmit_args()
7217 
    args.read(iprot)
7218 
    iprot.readMessageEnd()
7219 
    result = getProductFeedSubmit_result()
7220 
    try:
7221 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7222 
    except CatalogServiceException, cex:
7223 
      result.cex = cex
7224 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7225 
    result.write(oprot)
7226 
    oprot.writeMessageEnd()
7227 
    oprot.trans.flush()
9456 vikram.rag 7228 
 
9621 manish.sha 7229 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7230 
    args = addProductFeedSubmit_args()
7231 
    args.read(iprot)
7232 
    iprot.readMessageEnd()
7233 
    result = addProductFeedSubmit_result()
7234 
    try:
7235 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7236 
    except CatalogServiceException, cex:
7237 
      result.cex = cex
7238 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7239 
    result.write(oprot)
7240 
    oprot.writeMessageEnd()
7241 
    oprot.trans.flush()
7242 
 
7243 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7244 
    args = updateProductFeedSubmit_args()
7245 
    args.read(iprot)
7246 
    iprot.readMessageEnd()
7247 
    result = updateProductFeedSubmit_result()
7248 
    try:
7249 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7250 
    except CatalogServiceException, cex:
7251 
      result.cex = cex
7252 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7253 
    result.write(oprot)
7254 
    oprot.writeMessageEnd()
7255 
    oprot.trans.flush()
7256 
 
7257 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7258 
    args = deleteProductFeedSubmit_args()
7259 
    args.read(iprot)
7260 
    iprot.readMessageEnd()
7261 
    result = deleteProductFeedSubmit_result()
7262 
    try:
7263 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7264 
    except CatalogServiceException, cex:
7265 
      result.cex = cex
7266 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7267 
    result.write(oprot)
7268 
    oprot.writeMessageEnd()
7269 
    oprot.trans.flush()
7270 
 
7271 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7272 
    args = getAllProductFeedSubmit_args()
7273 
    args.read(iprot)
7274 
    iprot.readMessageEnd()
7275 
    result = getAllProductFeedSubmit_result()
7276 
    try:
7277 
      result.success = self._handler.getAllProductFeedSubmit()
7278 
    except CatalogServiceException, cex:
7279 
      result.cex = cex
7280 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7281 
    result.write(oprot)
7282 
    oprot.writeMessageEnd()
7283 
    oprot.trans.flush()
7284 
 
9724 kshitij.so 7285 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7286 
    args = getMarketplacedetailsForItem_args()
7287 
    args.read(iprot)
7288 
    iprot.readMessageEnd()
7289 
    result = getMarketplacedetailsForItem_result()
7290 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7291 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7292 
    result.write(oprot)
7293 
    oprot.writeMessageEnd()
7294 
    oprot.trans.flush()
9621 manish.sha 7295 
 
9724 kshitij.so 7296 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7297 
    args = updateMarketplaceAttributesForItem_args()
7298 
    args.read(iprot)
7299 
    iprot.readMessageEnd()
7300 
    result = updateMarketplaceAttributesForItem_result()
7301 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7302 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7303 
    result.write(oprot)
7304 
    oprot.writeMessageEnd()
7305 
    oprot.trans.flush()
7306 
 
9779 kshitij.so 7307 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7308 
    args = getCostingForMarketplace_args()
7309 
    args.read(iprot)
7310 
    iprot.readMessageEnd()
7311 
    result = getCostingForMarketplace_result()
7312 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7313 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
7317 
 
9776 vikram.rag 7318 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7319 
    args = getMarketPlaceItemsForPriceUpdate_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getMarketPlaceItemsForPriceUpdate_result()
7323 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7324 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
9724 kshitij.so 7328 
 
9776 vikram.rag 7329 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7330 
    args = updateMarketPlacePriceUpdateStatus_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7334 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7335 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
9861 rajveer 7340 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7341 
    args = updateItemHoldInventory_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = updateItemHoldInventory_result()
7345 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7346 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
9776 vikram.rag 7350 
 
9895 vikram.rag 7351 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
7352 
    args = updateNlcAtMarketplaces_args()
7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
7355 
    result = updateNlcAtMarketplaces_result()
7356 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
7357 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
7358 
    result.write(oprot)
7359 
    oprot.writeMessageEnd()
7360 
    oprot.trans.flush()
9861 rajveer 7361 
 
9895 vikram.rag 7362 
 
5944 mandeep.dh 7363 
# HELPER FUNCTIONS AND STRUCTURES
7364 
 
7365 
class addItem_args:
7366 
  """
7367 
  Attributes:
7368 
   - item
7369 
  """
7370 
 
7371 
  thrift_spec = (
7372 
    None, # 0
7373 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7374 
  )
7375 
 
7376 
  def __init__(self, item=None,):
7377 
    self.item = item
7378 
 
7379 
  def read(self, iprot):
7380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7382 
      return
7383 
    iprot.readStructBegin()
7384 
    while True:
7385 
      (fname, ftype, fid) = iprot.readFieldBegin()
7386 
      if ftype == TType.STOP:
7387 
        break
7388 
      if fid == 1:
7389 
        if ftype == TType.STRUCT:
7390 
          self.item = Item()
7391 
          self.item.read(iprot)
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      else:
7395 
        iprot.skip(ftype)
7396 
      iprot.readFieldEnd()
7397 
    iprot.readStructEnd()
7398 
 
7399 
  def write(self, oprot):
7400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7402 
      return
7403 
    oprot.writeStructBegin('addItem_args')
7404 
    if self.item is not None:
7405 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7406 
      self.item.write(oprot)
7407 
      oprot.writeFieldEnd()
7408 
    oprot.writeFieldStop()
7409 
    oprot.writeStructEnd()
7410 
 
7411 
  def validate(self):
7412 
    return
7413 
 
7414 
 
7415 
  def __repr__(self):
7416 
    L = ['%s=%r' % (key, value)
7417 
      for key, value in self.__dict__.iteritems()]
7418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7419 
 
7420 
  def __eq__(self, other):
7421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7422 
 
7423 
  def __ne__(self, other):
7424 
    return not (self == other)
7425 
 
7426 
class addItem_result:
7427 
  """
7428 
  Attributes:
7429 
   - success
7430 
   - cex
7431 
  """
7432 
 
7433 
  thrift_spec = (
7434 
    (0, TType.I64, 'success', None, None, ), # 0
7435 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7436 
  )
7437 
 
7438 
  def __init__(self, success=None, cex=None,):
7439 
    self.success = success
7440 
    self.cex = cex
7441 
 
7442 
  def read(self, iprot):
7443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7445 
      return
7446 
    iprot.readStructBegin()
7447 
    while True:
7448 
      (fname, ftype, fid) = iprot.readFieldBegin()
7449 
      if ftype == TType.STOP:
7450 
        break
7451 
      if fid == 0:
7452 
        if ftype == TType.I64:
7453 
          self.success = iprot.readI64();
7454 
        else:
7455 
          iprot.skip(ftype)
7456 
      elif fid == 1:
7457 
        if ftype == TType.STRUCT:
7458 
          self.cex = CatalogServiceException()
7459 
          self.cex.read(iprot)
7460 
        else:
7461 
          iprot.skip(ftype)
7462 
      else:
7463 
        iprot.skip(ftype)
7464 
      iprot.readFieldEnd()
7465 
    iprot.readStructEnd()
7466 
 
7467 
  def write(self, oprot):
7468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7470 
      return
7471 
    oprot.writeStructBegin('addItem_result')
7472 
    if self.success is not None:
7473 
      oprot.writeFieldBegin('success', TType.I64, 0)
7474 
      oprot.writeI64(self.success)
7475 
      oprot.writeFieldEnd()
7476 
    if self.cex is not None:
7477 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7478 
      self.cex.write(oprot)
7479 
      oprot.writeFieldEnd()
7480 
    oprot.writeFieldStop()
7481 
    oprot.writeStructEnd()
7482 
 
7483 
  def validate(self):
7484 
    return
7485 
 
7486 
 
7487 
  def __repr__(self):
7488 
    L = ['%s=%r' % (key, value)
7489 
      for key, value in self.__dict__.iteritems()]
7490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7491 
 
7492 
  def __eq__(self, other):
7493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7494 
 
7495 
  def __ne__(self, other):
7496 
    return not (self == other)
7497 
 
7498 
class updateItem_args:
7499 
  """
7500 
  Attributes:
7501 
   - item
7502 
  """
7503 
 
7504 
  thrift_spec = (
7505 
    None, # 0
7506 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7507 
  )
7508 
 
7509 
  def __init__(self, item=None,):
7510 
    self.item = item
7511 
 
7512 
  def read(self, iprot):
7513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7515 
      return
7516 
    iprot.readStructBegin()
7517 
    while True:
7518 
      (fname, ftype, fid) = iprot.readFieldBegin()
7519 
      if ftype == TType.STOP:
7520 
        break
7521 
      if fid == 1:
7522 
        if ftype == TType.STRUCT:
7523 
          self.item = Item()
7524 
          self.item.read(iprot)
7525 
        else:
7526 
          iprot.skip(ftype)
7527 
      else:
7528 
        iprot.skip(ftype)
7529 
      iprot.readFieldEnd()
7530 
    iprot.readStructEnd()
7531 
 
7532 
  def write(self, oprot):
7533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7535 
      return
7536 
    oprot.writeStructBegin('updateItem_args')
7537 
    if self.item is not None:
7538 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7539 
      self.item.write(oprot)
7540 
      oprot.writeFieldEnd()
7541 
    oprot.writeFieldStop()
7542 
    oprot.writeStructEnd()
7543 
 
7544 
  def validate(self):
7545 
    return
7546 
 
7547 
 
7548 
  def __repr__(self):
7549 
    L = ['%s=%r' % (key, value)
7550 
      for key, value in self.__dict__.iteritems()]
7551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7552 
 
7553 
  def __eq__(self, other):
7554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7555 
 
7556 
  def __ne__(self, other):
7557 
    return not (self == other)
7558 
 
7559 
class updateItem_result:
7560 
  """
7561 
  Attributes:
7562 
   - success
7563 
   - cex
7564 
  """
7565 
 
7566 
  thrift_spec = (
7567 
    (0, TType.I64, 'success', None, None, ), # 0
7568 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7569 
  )
7570 
 
7571 
  def __init__(self, success=None, cex=None,):
7572 
    self.success = success
7573 
    self.cex = cex
7574 
 
7575 
  def read(self, iprot):
7576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7578 
      return
7579 
    iprot.readStructBegin()
7580 
    while True:
7581 
      (fname, ftype, fid) = iprot.readFieldBegin()
7582 
      if ftype == TType.STOP:
7583 
        break
7584 
      if fid == 0:
7585 
        if ftype == TType.I64:
7586 
          self.success = iprot.readI64();
7587 
        else:
7588 
          iprot.skip(ftype)
7589 
      elif fid == 1:
7590 
        if ftype == TType.STRUCT:
7591 
          self.cex = CatalogServiceException()
7592 
          self.cex.read(iprot)
7593 
        else:
7594 
          iprot.skip(ftype)
7595 
      else:
7596 
        iprot.skip(ftype)
7597 
      iprot.readFieldEnd()
7598 
    iprot.readStructEnd()
7599 
 
7600 
  def write(self, oprot):
7601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7603 
      return
7604 
    oprot.writeStructBegin('updateItem_result')
7605 
    if self.success is not None:
7606 
      oprot.writeFieldBegin('success', TType.I64, 0)
7607 
      oprot.writeI64(self.success)
7608 
      oprot.writeFieldEnd()
7609 
    if self.cex is not None:
7610 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7611 
      self.cex.write(oprot)
7612 
      oprot.writeFieldEnd()
7613 
    oprot.writeFieldStop()
7614 
    oprot.writeStructEnd()
7615 
 
7616 
  def validate(self):
7617 
    return
7618 
 
7619 
 
7620 
  def __repr__(self):
7621 
    L = ['%s=%r' % (key, value)
7622 
      for key, value in self.__dict__.iteritems()]
7623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7624 
 
7625 
  def __eq__(self, other):
7626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7627 
 
7628 
  def __ne__(self, other):
7629 
    return not (self == other)
7630 
 
7631 
class isActive_args:
7632 
  """
7633 
  Attributes:
7634 
   - itemId
7635 
  """
7636 
 
7637 
  thrift_spec = (
7638 
    None, # 0
7639 
    (1, TType.I64, 'itemId', None, None, ), # 1
7640 
  )
7641 
 
7642 
  def __init__(self, itemId=None,):
7643 
    self.itemId = itemId
7644 
 
7645 
  def read(self, iprot):
7646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7648 
      return
7649 
    iprot.readStructBegin()
7650 
    while True:
7651 
      (fname, ftype, fid) = iprot.readFieldBegin()
7652 
      if ftype == TType.STOP:
7653 
        break
7654 
      if fid == 1:
7655 
        if ftype == TType.I64:
7656 
          self.itemId = iprot.readI64();
7657 
        else:
7658 
          iprot.skip(ftype)
7659 
      else:
7660 
        iprot.skip(ftype)
7661 
      iprot.readFieldEnd()
7662 
    iprot.readStructEnd()
7663 
 
7664 
  def write(self, oprot):
7665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7667 
      return
7668 
    oprot.writeStructBegin('isActive_args')
7669 
    if self.itemId is not None:
7670 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7671 
      oprot.writeI64(self.itemId)
7672 
      oprot.writeFieldEnd()
7673 
    oprot.writeFieldStop()
7674 
    oprot.writeStructEnd()
7675 
 
7676 
  def validate(self):
7677 
    return
7678 
 
7679 
 
7680 
  def __repr__(self):
7681 
    L = ['%s=%r' % (key, value)
7682 
      for key, value in self.__dict__.iteritems()]
7683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7684 
 
7685 
  def __eq__(self, other):
7686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7687 
 
7688 
  def __ne__(self, other):
7689 
    return not (self == other)
7690 
 
7691 
class isActive_result:
7692 
  """
7693 
  Attributes:
7694 
   - success
7695 
   - isex
7696 
  """
7697 
 
7698 
  thrift_spec = (
7699 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7700 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7701 
  )
7702 
 
7703 
  def __init__(self, success=None, isex=None,):
7704 
    self.success = success
7705 
    self.isex = isex
7706 
 
7707 
  def read(self, iprot):
7708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7710 
      return
7711 
    iprot.readStructBegin()
7712 
    while True:
7713 
      (fname, ftype, fid) = iprot.readFieldBegin()
7714 
      if ftype == TType.STOP:
7715 
        break
7716 
      if fid == 0:
7717 
        if ftype == TType.STRUCT:
7718 
          self.success = ItemShippingInfo()
7719 
          self.success.read(iprot)
7720 
        else:
7721 
          iprot.skip(ftype)
7722 
      elif fid == 1:
7723 
        if ftype == TType.STRUCT:
7724 
          self.isex = CatalogServiceException()
7725 
          self.isex.read(iprot)
7726 
        else:
7727 
          iprot.skip(ftype)
7728 
      else:
7729 
        iprot.skip(ftype)
7730 
      iprot.readFieldEnd()
7731 
    iprot.readStructEnd()
7732 
 
7733 
  def write(self, oprot):
7734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7736 
      return
7737 
    oprot.writeStructBegin('isActive_result')
7738 
    if self.success is not None:
7739 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7740 
      self.success.write(oprot)
7741 
      oprot.writeFieldEnd()
7742 
    if self.isex is not None:
7743 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7744 
      self.isex.write(oprot)
7745 
      oprot.writeFieldEnd()
7746 
    oprot.writeFieldStop()
7747 
    oprot.writeStructEnd()
7748 
 
7749 
  def validate(self):
7750 
    return
7751 
 
7752 
 
7753 
  def __repr__(self):
7754 
    L = ['%s=%r' % (key, value)
7755 
      for key, value in self.__dict__.iteritems()]
7756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7757 
 
7758 
  def __eq__(self, other):
7759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7760 
 
7761 
  def __ne__(self, other):
7762 
    return not (self == other)
7763 
 
7438 amit.gupta 7764 
class getItemsStatus_args:
7765 
  """
7766 
  Attributes:
7767 
   - itemIds
7768 
  """
7769 
 
7770 
  thrift_spec = (
7771 
    None, # 0
7772 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7773 
  )
7774 
 
7775 
  def __init__(self, itemIds=None,):
7776 
    self.itemIds = itemIds
7777 
 
7778 
  def read(self, iprot):
7779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7781 
      return
7782 
    iprot.readStructBegin()
7783 
    while True:
7784 
      (fname, ftype, fid) = iprot.readFieldBegin()
7785 
      if ftype == TType.STOP:
7786 
        break
7787 
      if fid == 1:
7788 
        if ftype == TType.LIST:
7789 
          self.itemIds = []
8590 kshitij.so 7790 
          (_etype33, _size30) = iprot.readListBegin()
7791 
          for _i34 in xrange(_size30):
7792 
            _elem35 = iprot.readI64();
7793 
            self.itemIds.append(_elem35)
7438 amit.gupta 7794 
          iprot.readListEnd()
7795 
        else:
7796 
          iprot.skip(ftype)
7797 
      else:
7798 
        iprot.skip(ftype)
7799 
      iprot.readFieldEnd()
7800 
    iprot.readStructEnd()
7801 
 
7802 
  def write(self, oprot):
7803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7805 
      return
7806 
    oprot.writeStructBegin('getItemsStatus_args')
7807 
    if self.itemIds is not None:
7808 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7809 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7810 
      for iter36 in self.itemIds:
7811 
        oprot.writeI64(iter36)
7438 amit.gupta 7812 
      oprot.writeListEnd()
7813 
      oprot.writeFieldEnd()
7814 
    oprot.writeFieldStop()
7815 
    oprot.writeStructEnd()
7816 
 
7817 
  def validate(self):
7818 
    return
7819 
 
7820 
 
7821 
  def __repr__(self):
7822 
    L = ['%s=%r' % (key, value)
7823 
      for key, value in self.__dict__.iteritems()]
7824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7825 
 
7826 
  def __eq__(self, other):
7827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7828 
 
7829 
  def __ne__(self, other):
7830 
    return not (self == other)
7831 
 
7832 
class getItemsStatus_result:
7833 
  """
7834 
  Attributes:
7835 
   - success
7836 
   - isex
7837 
  """
7838 
 
7839 
  thrift_spec = (
7840 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7841 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7842 
  )
7843 
 
7844 
  def __init__(self, success=None, isex=None,):
7845 
    self.success = success
7846 
    self.isex = isex
7847 
 
7848 
  def read(self, iprot):
7849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7851 
      return
7852 
    iprot.readStructBegin()
7853 
    while True:
7854 
      (fname, ftype, fid) = iprot.readFieldBegin()
7855 
      if ftype == TType.STOP:
7856 
        break
7857 
      if fid == 0:
7858 
        if ftype == TType.MAP:
7859 
          self.success = {}
8590 kshitij.so 7860 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7861 
          for _i41 in xrange(_size37):
7862 
            _key42 = iprot.readI64();
7863 
            _val43 = iprot.readBool();
7864 
            self.success[_key42] = _val43
7438 amit.gupta 7865 
          iprot.readMapEnd()
7866 
        else:
7867 
          iprot.skip(ftype)
7868 
      elif fid == 1:
7869 
        if ftype == TType.STRUCT:
7870 
          self.isex = CatalogServiceException()
7871 
          self.isex.read(iprot)
7872 
        else:
7873 
          iprot.skip(ftype)
7874 
      else:
7875 
        iprot.skip(ftype)
7876 
      iprot.readFieldEnd()
7877 
    iprot.readStructEnd()
7878 
 
7879 
  def write(self, oprot):
7880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7882 
      return
7883 
    oprot.writeStructBegin('getItemsStatus_result')
7884 
    if self.success is not None:
7885 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7886 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7887 
      for kiter44,viter45 in self.success.items():
7888 
        oprot.writeI64(kiter44)
7889 
        oprot.writeBool(viter45)
7438 amit.gupta 7890 
      oprot.writeMapEnd()
7891 
      oprot.writeFieldEnd()
7892 
    if self.isex is not None:
7893 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7894 
      self.isex.write(oprot)
7895 
      oprot.writeFieldEnd()
7896 
    oprot.writeFieldStop()
7897 
    oprot.writeStructEnd()
7898 
 
7899 
  def validate(self):
7900 
    return
7901 
 
7902 
 
7903 
  def __repr__(self):
7904 
    L = ['%s=%r' % (key, value)
7905 
      for key, value in self.__dict__.iteritems()]
7906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7907 
 
7908 
  def __eq__(self, other):
7909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7910 
 
7911 
  def __ne__(self, other):
7912 
    return not (self == other)
7913 
 
5944 mandeep.dh 7914 
class getItemStatusDescription_args:
7915 
  """
7916 
  Attributes:
7917 
   - itemId
7918 
  """
7919 
 
7920 
  thrift_spec = (
7921 
    None, # 0
7922 
    (1, TType.I64, 'itemId', None, None, ), # 1
7923 
  )
7924 
 
7925 
  def __init__(self, itemId=None,):
7926 
    self.itemId = itemId
7927 
 
7928 
  def read(self, iprot):
7929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7931 
      return
7932 
    iprot.readStructBegin()
7933 
    while True:
7934 
      (fname, ftype, fid) = iprot.readFieldBegin()
7935 
      if ftype == TType.STOP:
7936 
        break
7937 
      if fid == 1:
7938 
        if ftype == TType.I64:
7939 
          self.itemId = iprot.readI64();
7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
7951 
    oprot.writeStructBegin('getItemStatusDescription_args')
7952 
    if self.itemId is not None:
7953 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7954 
      oprot.writeI64(self.itemId)
7955 
      oprot.writeFieldEnd()
7956 
    oprot.writeFieldStop()
7957 
    oprot.writeStructEnd()
7958 
 
7959 
  def validate(self):
7960 
    return
7961 
 
7962 
 
7963 
  def __repr__(self):
7964 
    L = ['%s=%r' % (key, value)
7965 
      for key, value in self.__dict__.iteritems()]
7966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7967 
 
7968 
  def __eq__(self, other):
7969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7970 
 
7971 
  def __ne__(self, other):
7972 
    return not (self == other)
7973 
 
7974 
class getItemStatusDescription_result:
7975 
  """
7976 
  Attributes:
7977 
   - success
7978 
   - isex
7979 
  """
7980 
 
7981 
  thrift_spec = (
7982 
    (0, TType.STRING, 'success', None, None, ), # 0
7983 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7984 
  )
7985 
 
7986 
  def __init__(self, success=None, isex=None,):
7987 
    self.success = success
7988 
    self.isex = isex
7989 
 
7990 
  def read(self, iprot):
7991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7993 
      return
7994 
    iprot.readStructBegin()
7995 
    while True:
7996 
      (fname, ftype, fid) = iprot.readFieldBegin()
7997 
      if ftype == TType.STOP:
7998 
        break
7999 
      if fid == 0:
8000 
        if ftype == TType.STRING:
8001 
          self.success = iprot.readString();
8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 1:
8005 
        if ftype == TType.STRUCT:
8006 
          self.isex = CatalogServiceException()
8007 
          self.isex.read(iprot)
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      else:
8011 
        iprot.skip(ftype)
8012 
      iprot.readFieldEnd()
8013 
    iprot.readStructEnd()
8014 
 
8015 
  def write(self, oprot):
8016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8018 
      return
8019 
    oprot.writeStructBegin('getItemStatusDescription_result')
8020 
    if self.success is not None:
8021 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8022 
      oprot.writeString(self.success)
8023 
      oprot.writeFieldEnd()
8024 
    if self.isex is not None:
8025 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8026 
      self.isex.write(oprot)
8027 
      oprot.writeFieldEnd()
8028 
    oprot.writeFieldStop()
8029 
    oprot.writeStructEnd()
8030 
 
8031 
  def validate(self):
8032 
    return
8033 
 
8034 
 
8035 
  def __repr__(self):
8036 
    L = ['%s=%r' % (key, value)
8037 
      for key, value in self.__dict__.iteritems()]
8038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8039 
 
8040 
  def __eq__(self, other):
8041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8042 
 
8043 
  def __ne__(self, other):
8044 
    return not (self == other)
8045 
 
8046 
class startItemOn_args:
8047 
  """
8048 
  Attributes:
8049 
   - item_id
8050 
   - timestamp
8051 
  """
8052 
 
8053 
  thrift_spec = (
8054 
    None, # 0
8055 
    (1, TType.I64, 'item_id', None, None, ), # 1
8056 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8057 
  )
8058 
 
8059 
  def __init__(self, item_id=None, timestamp=None,):
8060 
    self.item_id = item_id
8061 
    self.timestamp = timestamp
8062 
 
8063 
  def read(self, iprot):
8064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8066 
      return
8067 
    iprot.readStructBegin()
8068 
    while True:
8069 
      (fname, ftype, fid) = iprot.readFieldBegin()
8070 
      if ftype == TType.STOP:
8071 
        break
8072 
      if fid == 1:
8073 
        if ftype == TType.I64:
8074 
          self.item_id = iprot.readI64();
8075 
        else:
8076 
          iprot.skip(ftype)
8077 
      elif fid == 2:
8078 
        if ftype == TType.I64:
8079 
          self.timestamp = iprot.readI64();
8080 
        else:
8081 
          iprot.skip(ftype)
8082 
      else:
8083 
        iprot.skip(ftype)
8084 
      iprot.readFieldEnd()
8085 
    iprot.readStructEnd()
8086 
 
8087 
  def write(self, oprot):
8088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8090 
      return
8091 
    oprot.writeStructBegin('startItemOn_args')
8092 
    if self.item_id is not None:
8093 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8094 
      oprot.writeI64(self.item_id)
8095 
      oprot.writeFieldEnd()
8096 
    if self.timestamp is not None:
8097 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8098 
      oprot.writeI64(self.timestamp)
8099 
      oprot.writeFieldEnd()
8100 
    oprot.writeFieldStop()
8101 
    oprot.writeStructEnd()
8102 
 
8103 
  def validate(self):
8104 
    return
8105 
 
8106 
 
8107 
  def __repr__(self):
8108 
    L = ['%s=%r' % (key, value)
8109 
      for key, value in self.__dict__.iteritems()]
8110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8111 
 
8112 
  def __eq__(self, other):
8113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8114 
 
8115 
  def __ne__(self, other):
8116 
    return not (self == other)
8117 
 
8118 
class startItemOn_result:
8119 
  """
8120 
  Attributes:
8121 
   - cex
8122 
  """
8123 
 
8124 
  thrift_spec = (
8125 
    None, # 0
8126 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8127 
  )
8128 
 
8129 
  def __init__(self, cex=None,):
8130 
    self.cex = cex
8131 
 
8132 
  def read(self, iprot):
8133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8135 
      return
8136 
    iprot.readStructBegin()
8137 
    while True:
8138 
      (fname, ftype, fid) = iprot.readFieldBegin()
8139 
      if ftype == TType.STOP:
8140 
        break
8141 
      if fid == 1:
8142 
        if ftype == TType.STRUCT:
8143 
          self.cex = CatalogServiceException()
8144 
          self.cex.read(iprot)
8145 
        else:
8146 
          iprot.skip(ftype)
8147 
      else:
8148 
        iprot.skip(ftype)
8149 
      iprot.readFieldEnd()
8150 
    iprot.readStructEnd()
8151 
 
8152 
  def write(self, oprot):
8153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8155 
      return
8156 
    oprot.writeStructBegin('startItemOn_result')
8157 
    if self.cex is not None:
8158 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8159 
      self.cex.write(oprot)
8160 
      oprot.writeFieldEnd()
8161 
    oprot.writeFieldStop()
8162 
    oprot.writeStructEnd()
8163 
 
8164 
  def validate(self):
8165 
    return
8166 
 
8167 
 
8168 
  def __repr__(self):
8169 
    L = ['%s=%r' % (key, value)
8170 
      for key, value in self.__dict__.iteritems()]
8171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8172 
 
8173 
  def __eq__(self, other):
8174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8175 
 
8176 
  def __ne__(self, other):
8177 
    return not (self == other)
8178 
 
8179 
class retireItemOn_args:
8180 
  """
8181 
  Attributes:
8182 
   - item_id
8183 
   - timestamp
8184 
  """
8185 
 
8186 
  thrift_spec = (
8187 
    None, # 0
8188 
    (1, TType.I64, 'item_id', None, None, ), # 1
8189 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8190 
  )
8191 
 
8192 
  def __init__(self, item_id=None, timestamp=None,):
8193 
    self.item_id = item_id
8194 
    self.timestamp = timestamp
8195 
 
8196 
  def read(self, iprot):
8197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8199 
      return
8200 
    iprot.readStructBegin()
8201 
    while True:
8202 
      (fname, ftype, fid) = iprot.readFieldBegin()
8203 
      if ftype == TType.STOP:
8204 
        break
8205 
      if fid == 1:
8206 
        if ftype == TType.I64:
8207 
          self.item_id = iprot.readI64();
8208 
        else:
8209 
          iprot.skip(ftype)
8210 
      elif fid == 2:
8211 
        if ftype == TType.I64:
8212 
          self.timestamp = iprot.readI64();
8213 
        else:
8214 
          iprot.skip(ftype)
8215 
      else:
8216 
        iprot.skip(ftype)
8217 
      iprot.readFieldEnd()
8218 
    iprot.readStructEnd()
8219 
 
8220 
  def write(self, oprot):
8221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8223 
      return
8224 
    oprot.writeStructBegin('retireItemOn_args')
8225 
    if self.item_id is not None:
8226 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8227 
      oprot.writeI64(self.item_id)
8228 
      oprot.writeFieldEnd()
8229 
    if self.timestamp is not None:
8230 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8231 
      oprot.writeI64(self.timestamp)
8232 
      oprot.writeFieldEnd()
8233 
    oprot.writeFieldStop()
8234 
    oprot.writeStructEnd()
8235 
 
8236 
  def validate(self):
8237 
    return
8238 
 
8239 
 
8240 
  def __repr__(self):
8241 
    L = ['%s=%r' % (key, value)
8242 
      for key, value in self.__dict__.iteritems()]
8243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8244 
 
8245 
  def __eq__(self, other):
8246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8247 
 
8248 
  def __ne__(self, other):
8249 
    return not (self == other)
8250 
 
8251 
class retireItemOn_result:
8252 
  """
8253 
  Attributes:
8254 
   - cex
8255 
  """
8256 
 
8257 
  thrift_spec = (
8258 
    None, # 0
8259 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8260 
  )
8261 
 
8262 
  def __init__(self, cex=None,):
8263 
    self.cex = cex
8264 
 
8265 
  def read(self, iprot):
8266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8268 
      return
8269 
    iprot.readStructBegin()
8270 
    while True:
8271 
      (fname, ftype, fid) = iprot.readFieldBegin()
8272 
      if ftype == TType.STOP:
8273 
        break
8274 
      if fid == 1:
8275 
        if ftype == TType.STRUCT:
8276 
          self.cex = CatalogServiceException()
8277 
          self.cex.read(iprot)
8278 
        else:
8279 
          iprot.skip(ftype)
8280 
      else:
8281 
        iprot.skip(ftype)
8282 
      iprot.readFieldEnd()
8283 
    iprot.readStructEnd()
8284 
 
8285 
  def write(self, oprot):
8286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8288 
      return
8289 
    oprot.writeStructBegin('retireItemOn_result')
8290 
    if self.cex is not None:
8291 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8292 
      self.cex.write(oprot)
8293 
      oprot.writeFieldEnd()
8294 
    oprot.writeFieldStop()
8295 
    oprot.writeStructEnd()
8296 
 
8297 
  def validate(self):
8298 
    return
8299 
 
8300 
 
8301 
  def __repr__(self):
8302 
    L = ['%s=%r' % (key, value)
8303 
      for key, value in self.__dict__.iteritems()]
8304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8305 
 
8306 
  def __eq__(self, other):
8307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8308 
 
8309 
  def __ne__(self, other):
8310 
    return not (self == other)
8311 
 
8312 
class changeItemStatus_args:
8313 
  """
8314 
  Attributes:
8315 
   - item_id
8316 
   - timestamp
8317 
   - newstatus
8318 
  """
8319 
 
8320 
  thrift_spec = (
8321 
    None, # 0
8322 
    (1, TType.I64, 'item_id', None, None, ), # 1
8323 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8324 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8325 
  )
8326 
 
8327 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8328 
    self.item_id = item_id
8329 
    self.timestamp = timestamp
8330 
    self.newstatus = newstatus
8331 
 
8332 
  def read(self, iprot):
8333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8335 
      return
8336 
    iprot.readStructBegin()
8337 
    while True:
8338 
      (fname, ftype, fid) = iprot.readFieldBegin()
8339 
      if ftype == TType.STOP:
8340 
        break
8341 
      if fid == 1:
8342 
        if ftype == TType.I64:
8343 
          self.item_id = iprot.readI64();
8344 
        else:
8345 
          iprot.skip(ftype)
8346 
      elif fid == 2:
8347 
        if ftype == TType.I64:
8348 
          self.timestamp = iprot.readI64();
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      elif fid == 3:
8352 
        if ftype == TType.I32:
8353 
          self.newstatus = iprot.readI32();
8354 
        else:
8355 
          iprot.skip(ftype)
8356 
      else:
8357 
        iprot.skip(ftype)
8358 
      iprot.readFieldEnd()
8359 
    iprot.readStructEnd()
8360 
 
8361 
  def write(self, oprot):
8362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8364 
      return
8365 
    oprot.writeStructBegin('changeItemStatus_args')
8366 
    if self.item_id is not None:
8367 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8368 
      oprot.writeI64(self.item_id)
8369 
      oprot.writeFieldEnd()
8370 
    if self.timestamp is not None:
8371 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8372 
      oprot.writeI64(self.timestamp)
8373 
      oprot.writeFieldEnd()
8374 
    if self.newstatus is not None:
8375 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8376 
      oprot.writeI32(self.newstatus)
8377 
      oprot.writeFieldEnd()
8378 
    oprot.writeFieldStop()
8379 
    oprot.writeStructEnd()
8380 
 
8381 
  def validate(self):
8382 
    return
8383 
 
8384 
 
8385 
  def __repr__(self):
8386 
    L = ['%s=%r' % (key, value)
8387 
      for key, value in self.__dict__.iteritems()]
8388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8389 
 
8390 
  def __eq__(self, other):
8391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8392 
 
8393 
  def __ne__(self, other):
8394 
    return not (self == other)
8395 
 
8396 
class changeItemStatus_result:
8397 
  """
8398 
  Attributes:
8399 
   - cex
8400 
  """
8401 
 
8402 
  thrift_spec = (
8403 
    None, # 0
8404 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8405 
  )
8406 
 
8407 
  def __init__(self, cex=None,):
8408 
    self.cex = cex
8409 
 
8410 
  def read(self, iprot):
8411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8413 
      return
8414 
    iprot.readStructBegin()
8415 
    while True:
8416 
      (fname, ftype, fid) = iprot.readFieldBegin()
8417 
      if ftype == TType.STOP:
8418 
        break
8419 
      if fid == 1:
8420 
        if ftype == TType.STRUCT:
8421 
          self.cex = CatalogServiceException()
8422 
          self.cex.read(iprot)
8423 
        else:
8424 
          iprot.skip(ftype)
8425 
      else:
8426 
        iprot.skip(ftype)
8427 
      iprot.readFieldEnd()
8428 
    iprot.readStructEnd()
8429 
 
8430 
  def write(self, oprot):
8431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8433 
      return
8434 
    oprot.writeStructBegin('changeItemStatus_result')
8435 
    if self.cex is not None:
8436 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8437 
      self.cex.write(oprot)
8438 
      oprot.writeFieldEnd()
8439 
    oprot.writeFieldStop()
8440 
    oprot.writeStructEnd()
8441 
 
8442 
  def validate(self):
8443 
    return
8444 
 
8445 
 
8446 
  def __repr__(self):
8447 
    L = ['%s=%r' % (key, value)
8448 
      for key, value in self.__dict__.iteritems()]
8449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8450 
 
8451 
  def __eq__(self, other):
8452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8453 
 
8454 
  def __ne__(self, other):
8455 
    return not (self == other)
8456 
 
8457 
class getItem_args:
8458 
  """
8459 
  Attributes:
8460 
   - item_id
8461 
  """
8462 
 
8463 
  thrift_spec = (
8464 
    None, # 0
8465 
    (1, TType.I64, 'item_id', None, None, ), # 1
8466 
  )
8467 
 
8468 
  def __init__(self, item_id=None,):
8469 
    self.item_id = item_id
8470 
 
8471 
  def read(self, iprot):
8472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8474 
      return
8475 
    iprot.readStructBegin()
8476 
    while True:
8477 
      (fname, ftype, fid) = iprot.readFieldBegin()
8478 
      if ftype == TType.STOP:
8479 
        break
8480 
      if fid == 1:
8481 
        if ftype == TType.I64:
8482 
          self.item_id = iprot.readI64();
8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      else:
8486 
        iprot.skip(ftype)
8487 
      iprot.readFieldEnd()
8488 
    iprot.readStructEnd()
8489 
 
8490 
  def write(self, oprot):
8491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8493 
      return
8494 
    oprot.writeStructBegin('getItem_args')
8495 
    if self.item_id is not None:
8496 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8497 
      oprot.writeI64(self.item_id)
8498 
      oprot.writeFieldEnd()
8499 
    oprot.writeFieldStop()
8500 
    oprot.writeStructEnd()
8501 
 
8502 
  def validate(self):
8503 
    return
8504 
 
8505 
 
8506 
  def __repr__(self):
8507 
    L = ['%s=%r' % (key, value)
8508 
      for key, value in self.__dict__.iteritems()]
8509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8510 
 
8511 
  def __eq__(self, other):
8512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8513 
 
8514 
  def __ne__(self, other):
8515 
    return not (self == other)
8516 
 
8517 
class getItem_result:
8518 
  """
8519 
  Attributes:
8520 
   - success
8521 
   - cex
8522 
  """
8523 
 
8524 
  thrift_spec = (
8525 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
8526 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8527 
  )
8528 
 
8529 
  def __init__(self, success=None, cex=None,):
8530 
    self.success = success
8531 
    self.cex = cex
8532 
 
8533 
  def read(self, iprot):
8534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8536 
      return
8537 
    iprot.readStructBegin()
8538 
    while True:
8539 
      (fname, ftype, fid) = iprot.readFieldBegin()
8540 
      if ftype == TType.STOP:
8541 
        break
8542 
      if fid == 0:
8543 
        if ftype == TType.STRUCT:
8544 
          self.success = Item()
8545 
          self.success.read(iprot)
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      elif fid == 1:
8549 
        if ftype == TType.STRUCT:
8550 
          self.cex = CatalogServiceException()
8551 
          self.cex.read(iprot)
8552 
        else:
8553 
          iprot.skip(ftype)
8554 
      else:
8555 
        iprot.skip(ftype)
8556 
      iprot.readFieldEnd()
8557 
    iprot.readStructEnd()
8558 
 
8559 
  def write(self, oprot):
8560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8562 
      return
8563 
    oprot.writeStructBegin('getItem_result')
8564 
    if self.success is not None:
8565 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8566 
      self.success.write(oprot)
8567 
      oprot.writeFieldEnd()
8568 
    if self.cex is not None:
8569 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8570 
      self.cex.write(oprot)
8571 
      oprot.writeFieldEnd()
8572 
    oprot.writeFieldStop()
8573 
    oprot.writeStructEnd()
8574 
 
8575 
  def validate(self):
8576 
    return
8577 
 
8578 
 
8579 
  def __repr__(self):
8580 
    L = ['%s=%r' % (key, value)
8581 
      for key, value in self.__dict__.iteritems()]
8582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8583 
 
8584 
  def __eq__(self, other):
8585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8586 
 
8587 
  def __ne__(self, other):
8588 
    return not (self == other)
8589 
 
8590 
class getItemsByCatalogId_args:
8591 
  """
8592 
  Attributes:
8593 
   - catalog_item_id
8594 
  """
8595 
 
8596 
  thrift_spec = (
8597 
    None, # 0
8598 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8599 
  )
8600 
 
8601 
  def __init__(self, catalog_item_id=None,):
8602 
    self.catalog_item_id = catalog_item_id
8603 
 
8604 
  def read(self, iprot):
8605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8607 
      return
8608 
    iprot.readStructBegin()
8609 
    while True:
8610 
      (fname, ftype, fid) = iprot.readFieldBegin()
8611 
      if ftype == TType.STOP:
8612 
        break
8613 
      if fid == 1:
8614 
        if ftype == TType.I64:
8615 
          self.catalog_item_id = iprot.readI64();
8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
8627 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8628 
    if self.catalog_item_id is not None:
8629 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8630 
      oprot.writeI64(self.catalog_item_id)
8631 
      oprot.writeFieldEnd()
8632 
    oprot.writeFieldStop()
8633 
    oprot.writeStructEnd()
8634 
 
8635 
  def validate(self):
8636 
    return
8637 
 
8638 
 
8639 
  def __repr__(self):
8640 
    L = ['%s=%r' % (key, value)
8641 
      for key, value in self.__dict__.iteritems()]
8642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8643 
 
8644 
  def __eq__(self, other):
8645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8646 
 
8647 
  def __ne__(self, other):
8648 
    return not (self == other)
8649 
 
8650 
class getItemsByCatalogId_result:
8651 
  """
8652 
  Attributes:
8653 
   - success
8654 
   - cex
8655 
  """
8656 
 
8657 
  thrift_spec = (
8658 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8659 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8660 
  )
8661 
 
8662 
  def __init__(self, success=None, cex=None,):
8663 
    self.success = success
8664 
    self.cex = cex
8665 
 
8666 
  def read(self, iprot):
8667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8669 
      return
8670 
    iprot.readStructBegin()
8671 
    while True:
8672 
      (fname, ftype, fid) = iprot.readFieldBegin()
8673 
      if ftype == TType.STOP:
8674 
        break
8675 
      if fid == 0:
8676 
        if ftype == TType.LIST:
8677 
          self.success = []
8590 kshitij.so 8678 
          (_etype49, _size46) = iprot.readListBegin()
8679 
          for _i50 in xrange(_size46):
8680 
            _elem51 = Item()
8681 
            _elem51.read(iprot)
8682 
            self.success.append(_elem51)
5944 mandeep.dh 8683 
          iprot.readListEnd()
8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      elif fid == 1:
8687 
        if ftype == TType.STRUCT:
8688 
          self.cex = CatalogServiceException()
8689 
          self.cex.read(iprot)
8690 
        else:
8691 
          iprot.skip(ftype)
8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
8701 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8702 
    if self.success is not None:
8703 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8704 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8705 
      for iter52 in self.success:
8706 
        iter52.write(oprot)
5944 mandeep.dh 8707 
      oprot.writeListEnd()
8708 
      oprot.writeFieldEnd()
8709 
    if self.cex is not None:
8710 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8711 
      self.cex.write(oprot)
8712 
      oprot.writeFieldEnd()
8713 
    oprot.writeFieldStop()
8714 
    oprot.writeStructEnd()
8715 
 
8716 
  def validate(self):
8717 
    return
8718 
 
8719 
 
8720 
  def __repr__(self):
8721 
    L = ['%s=%r' % (key, value)
8722 
      for key, value in self.__dict__.iteritems()]
8723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8724 
 
8725 
  def __eq__(self, other):
8726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8727 
 
8728 
  def __ne__(self, other):
8729 
    return not (self == other)
8730 
 
8731 
class getValidItemsByCatalogId_args:
8732 
  """
8733 
  Attributes:
8734 
   - catalog_item_id
8735 
  """
8736 
 
8737 
  thrift_spec = (
8738 
    None, # 0
8739 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8740 
  )
8741 
 
8742 
  def __init__(self, catalog_item_id=None,):
8743 
    self.catalog_item_id = catalog_item_id
8744 
 
8745 
  def read(self, iprot):
8746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8748 
      return
8749 
    iprot.readStructBegin()
8750 
    while True:
8751 
      (fname, ftype, fid) = iprot.readFieldBegin()
8752 
      if ftype == TType.STOP:
8753 
        break
8754 
      if fid == 1:
8755 
        if ftype == TType.I64:
8756 
          self.catalog_item_id = iprot.readI64();
8757 
        else:
8758 
          iprot.skip(ftype)
8759 
      else:
8760 
        iprot.skip(ftype)
8761 
      iprot.readFieldEnd()
8762 
    iprot.readStructEnd()
8763 
 
8764 
  def write(self, oprot):
8765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8767 
      return
8768 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8769 
    if self.catalog_item_id is not None:
8770 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8771 
      oprot.writeI64(self.catalog_item_id)
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 getValidItemsByCatalogId_result:
8792 
  """
8793 
  Attributes:
8794 
   - success
8795 
   - cex
8796 
  """
8797 
 
8798 
  thrift_spec = (
8799 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8800 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8801 
  )
8802 
 
8803 
  def __init__(self, success=None, cex=None,):
8804 
    self.success = success
8805 
    self.cex = cex
8806 
 
8807 
  def read(self, iprot):
8808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8810 
      return
8811 
    iprot.readStructBegin()
8812 
    while True:
8813 
      (fname, ftype, fid) = iprot.readFieldBegin()
8814 
      if ftype == TType.STOP:
8815 
        break
8816 
      if fid == 0:
8817 
        if ftype == TType.LIST:
8818 
          self.success = []
8590 kshitij.so 8819 
          (_etype56, _size53) = iprot.readListBegin()
8820 
          for _i57 in xrange(_size53):
8821 
            _elem58 = Item()
8822 
            _elem58.read(iprot)
8823 
            self.success.append(_elem58)
5944 mandeep.dh 8824 
          iprot.readListEnd()
8825 
        else:
8826 
          iprot.skip(ftype)
8827 
      elif fid == 1:
8828 
        if ftype == TType.STRUCT:
8829 
          self.cex = CatalogServiceException()
8830 
          self.cex.read(iprot)
8831 
        else:
8832 
          iprot.skip(ftype)
8833 
      else:
8834 
        iprot.skip(ftype)
8835 
      iprot.readFieldEnd()
8836 
    iprot.readStructEnd()
8837 
 
8838 
  def write(self, oprot):
8839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8841 
      return
8842 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8843 
    if self.success is not None:
8844 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8845 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8846 
      for iter59 in self.success:
8847 
        iter59.write(oprot)
5944 mandeep.dh 8848 
      oprot.writeListEnd()
8849 
      oprot.writeFieldEnd()
8850 
    if self.cex is not None:
8851 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8852 
      self.cex.write(oprot)
8853 
      oprot.writeFieldEnd()
8854 
    oprot.writeFieldStop()
8855 
    oprot.writeStructEnd()
8856 
 
8857 
  def validate(self):
8858 
    return
8859 
 
8860 
 
8861 
  def __repr__(self):
8862 
    L = ['%s=%r' % (key, value)
8863 
      for key, value in self.__dict__.iteritems()]
8864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8865 
 
8866 
  def __eq__(self, other):
8867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8868 
 
8869 
  def __ne__(self, other):
8870 
    return not (self == other)
8871 
 
8872 
class getAllItems_args:
8873 
  """
8874 
  Attributes:
8875 
   - isActive
8876 
  """
8877 
 
8878 
  thrift_spec = (
8879 
    None, # 0
8880 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8881 
  )
8882 
 
8883 
  def __init__(self, isActive=None,):
8884 
    self.isActive = isActive
8885 
 
8886 
  def read(self, iprot):
8887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8889 
      return
8890 
    iprot.readStructBegin()
8891 
    while True:
8892 
      (fname, ftype, fid) = iprot.readFieldBegin()
8893 
      if ftype == TType.STOP:
8894 
        break
8895 
      if fid == 1:
8896 
        if ftype == TType.BOOL:
8897 
          self.isActive = iprot.readBool();
8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      else:
8901 
        iprot.skip(ftype)
8902 
      iprot.readFieldEnd()
8903 
    iprot.readStructEnd()
8904 
 
8905 
  def write(self, oprot):
8906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8908 
      return
8909 
    oprot.writeStructBegin('getAllItems_args')
8910 
    if self.isActive is not None:
8911 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8912 
      oprot.writeBool(self.isActive)
8913 
      oprot.writeFieldEnd()
8914 
    oprot.writeFieldStop()
8915 
    oprot.writeStructEnd()
8916 
 
8917 
  def validate(self):
8918 
    return
8919 
 
8920 
 
8921 
  def __repr__(self):
8922 
    L = ['%s=%r' % (key, value)
8923 
      for key, value in self.__dict__.iteritems()]
8924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8925 
 
8926 
  def __eq__(self, other):
8927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8928 
 
8929 
  def __ne__(self, other):
8930 
    return not (self == other)
8931 
 
8932 
class getAllItems_result:
8933 
  """
8934 
  Attributes:
8935 
   - success
8936 
   - cex
8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8941 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8942 
  )
8943 
 
8944 
  def __init__(self, success=None, cex=None,):
8945 
    self.success = success
8946 
    self.cex = cex
8947 
 
8948 
  def read(self, iprot):
8949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8951 
      return
8952 
    iprot.readStructBegin()
8953 
    while True:
8954 
      (fname, ftype, fid) = iprot.readFieldBegin()
8955 
      if ftype == TType.STOP:
8956 
        break
8957 
      if fid == 0:
8958 
        if ftype == TType.LIST:
8959 
          self.success = []
8590 kshitij.so 8960 
          (_etype63, _size60) = iprot.readListBegin()
8961 
          for _i64 in xrange(_size60):
8962 
            _elem65 = Item()
8963 
            _elem65.read(iprot)
8964 
            self.success.append(_elem65)
5944 mandeep.dh 8965 
          iprot.readListEnd()
8966 
        else:
8967 
          iprot.skip(ftype)
8968 
      elif fid == 1:
8969 
        if ftype == TType.STRUCT:
8970 
          self.cex = CatalogServiceException()
8971 
          self.cex.read(iprot)
8972 
        else:
8973 
          iprot.skip(ftype)
8974 
      else:
8975 
        iprot.skip(ftype)
8976 
      iprot.readFieldEnd()
8977 
    iprot.readStructEnd()
8978 
 
8979 
  def write(self, oprot):
8980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8982 
      return
8983 
    oprot.writeStructBegin('getAllItems_result')
8984 
    if self.success is not None:
8985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8987 
      for iter66 in self.success:
8988 
        iter66.write(oprot)
5944 mandeep.dh 8989 
      oprot.writeListEnd()
8990 
      oprot.writeFieldEnd()
8991 
    if self.cex is not None:
8992 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8993 
      self.cex.write(oprot)
8994 
      oprot.writeFieldEnd()
8995 
    oprot.writeFieldStop()
8996 
    oprot.writeStructEnd()
8997 
 
8998 
  def validate(self):
8999 
    return
9000 
 
9001 
 
9002 
  def __repr__(self):
9003 
    L = ['%s=%r' % (key, value)
9004 
      for key, value in self.__dict__.iteritems()]
9005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9006 
 
9007 
  def __eq__(self, other):
9008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9009 
 
9010 
  def __ne__(self, other):
9011 
    return not (self == other)
9012 
 
9013 
class getAllItemsByStatus_args:
9014 
  """
9015 
  Attributes:
9016 
   - itemStatus
9017 
  """
9018 
 
9019 
  thrift_spec = (
9020 
    None, # 0
9021 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9022 
  )
9023 
 
9024 
  def __init__(self, itemStatus=None,):
9025 
    self.itemStatus = itemStatus
9026 
 
9027 
  def read(self, iprot):
9028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9030 
      return
9031 
    iprot.readStructBegin()
9032 
    while True:
9033 
      (fname, ftype, fid) = iprot.readFieldBegin()
9034 
      if ftype == TType.STOP:
9035 
        break
9036 
      if fid == 1:
9037 
        if ftype == TType.I32:
9038 
          self.itemStatus = iprot.readI32();
9039 
        else:
9040 
          iprot.skip(ftype)
9041 
      else:
9042 
        iprot.skip(ftype)
9043 
      iprot.readFieldEnd()
9044 
    iprot.readStructEnd()
9045 
 
9046 
  def write(self, oprot):
9047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9049 
      return
9050 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9051 
    if self.itemStatus is not None:
9052 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9053 
      oprot.writeI32(self.itemStatus)
9054 
      oprot.writeFieldEnd()
9055 
    oprot.writeFieldStop()
9056 
    oprot.writeStructEnd()
9057 
 
9058 
  def validate(self):
9059 
    return
9060 
 
9061 
 
9062 
  def __repr__(self):
9063 
    L = ['%s=%r' % (key, value)
9064 
      for key, value in self.__dict__.iteritems()]
9065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9066 
 
9067 
  def __eq__(self, other):
9068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9069 
 
9070 
  def __ne__(self, other):
9071 
    return not (self == other)
9072 
 
9073 
class getAllItemsByStatus_result:
9074 
  """
9075 
  Attributes:
9076 
   - success
9077 
   - cex
9078 
  """
9079 
 
9080 
  thrift_spec = (
9081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9082 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9083 
  )
9084 
 
9085 
  def __init__(self, success=None, cex=None,):
9086 
    self.success = success
9087 
    self.cex = cex
9088 
 
9089 
  def read(self, iprot):
9090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9092 
      return
9093 
    iprot.readStructBegin()
9094 
    while True:
9095 
      (fname, ftype, fid) = iprot.readFieldBegin()
9096 
      if ftype == TType.STOP:
9097 
        break
9098 
      if fid == 0:
9099 
        if ftype == TType.LIST:
9100 
          self.success = []
8590 kshitij.so 9101 
          (_etype70, _size67) = iprot.readListBegin()
9102 
          for _i71 in xrange(_size67):
9103 
            _elem72 = Item()
9104 
            _elem72.read(iprot)
9105 
            self.success.append(_elem72)
5944 mandeep.dh 9106 
          iprot.readListEnd()
9107 
        else:
9108 
          iprot.skip(ftype)
9109 
      elif fid == 1:
9110 
        if ftype == TType.STRUCT:
9111 
          self.cex = CatalogServiceException()
9112 
          self.cex.read(iprot)
9113 
        else:
9114 
          iprot.skip(ftype)
9115 
      else:
9116 
        iprot.skip(ftype)
9117 
      iprot.readFieldEnd()
9118 
    iprot.readStructEnd()
9119 
 
9120 
  def write(self, oprot):
9121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9123 
      return
9124 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9125 
    if self.success is not None:
9126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9128 
      for iter73 in self.success:
9129 
        iter73.write(oprot)
5944 mandeep.dh 9130 
      oprot.writeListEnd()
9131 
      oprot.writeFieldEnd()
9132 
    if self.cex is not None:
9133 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9134 
      self.cex.write(oprot)
9135 
      oprot.writeFieldEnd()
9136 
    oprot.writeFieldStop()
9137 
    oprot.writeStructEnd()
9138 
 
9139 
  def validate(self):
9140 
    return
9141 
 
9142 
 
9143 
  def __repr__(self):
9144 
    L = ['%s=%r' % (key, value)
9145 
      for key, value in self.__dict__.iteritems()]
9146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9147 
 
9148 
  def __eq__(self, other):
9149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9150 
 
9151 
  def __ne__(self, other):
9152 
    return not (self == other)
9153 
 
9154 
class markItemAsContentComplete_args:
9155 
  """
9156 
  Attributes:
9157 
   - entityId
9158 
   - category
9159 
   - brand
9160 
   - modelName
9161 
   - modelNumber
9253 rajveer 9162 
   - isAndroid
5944 mandeep.dh 9163 
  """
9164 
 
9165 
  thrift_spec = (
9166 
    None, # 0
9167 
    (1, TType.I64, 'entityId', None, None, ), # 1
9168 
    (2, TType.I64, 'category', None, None, ), # 2
9169 
    (3, TType.STRING, 'brand', None, None, ), # 3
9170 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9171 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9172 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9173 
  )
9174 
 
9253 rajveer 9175 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9176 
    self.entityId = entityId
9177 
    self.category = category
9178 
    self.brand = brand
9179 
    self.modelName = modelName
9180 
    self.modelNumber = modelNumber
9253 rajveer 9181 
    self.isAndroid = isAndroid
5944 mandeep.dh 9182 
 
9183 
  def read(self, iprot):
9184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9186 
      return
9187 
    iprot.readStructBegin()
9188 
    while True:
9189 
      (fname, ftype, fid) = iprot.readFieldBegin()
9190 
      if ftype == TType.STOP:
9191 
        break
9192 
      if fid == 1:
9193 
        if ftype == TType.I64:
9194 
          self.entityId = iprot.readI64();
9195 
        else:
9196 
          iprot.skip(ftype)
9197 
      elif fid == 2:
9198 
        if ftype == TType.I64:
9199 
          self.category = iprot.readI64();
9200 
        else:
9201 
          iprot.skip(ftype)
9202 
      elif fid == 3:
9203 
        if ftype == TType.STRING:
9204 
          self.brand = iprot.readString();
9205 
        else:
9206 
          iprot.skip(ftype)
9207 
      elif fid == 4:
9208 
        if ftype == TType.STRING:
9209 
          self.modelName = iprot.readString();
9210 
        else:
9211 
          iprot.skip(ftype)
9212 
      elif fid == 5:
9213 
        if ftype == TType.STRING:
9214 
          self.modelNumber = iprot.readString();
9215 
        else:
9216 
          iprot.skip(ftype)
9253 rajveer 9217 
      elif fid == 6:
9218 
        if ftype == TType.BOOL:
9219 
          self.isAndroid = iprot.readBool();
9220 
        else:
9221 
          iprot.skip(ftype)
5944 mandeep.dh 9222 
      else:
9223 
        iprot.skip(ftype)
9224 
      iprot.readFieldEnd()
9225 
    iprot.readStructEnd()
9226 
 
9227 
  def write(self, oprot):
9228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9230 
      return
9231 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9232 
    if self.entityId is not None:
9233 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9234 
      oprot.writeI64(self.entityId)
9235 
      oprot.writeFieldEnd()
9236 
    if self.category is not None:
9237 
      oprot.writeFieldBegin('category', TType.I64, 2)
9238 
      oprot.writeI64(self.category)
9239 
      oprot.writeFieldEnd()
9240 
    if self.brand is not None:
9241 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9242 
      oprot.writeString(self.brand)
9243 
      oprot.writeFieldEnd()
9244 
    if self.modelName is not None:
9245 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9246 
      oprot.writeString(self.modelName)
9247 
      oprot.writeFieldEnd()
9248 
    if self.modelNumber is not None:
9249 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9250 
      oprot.writeString(self.modelNumber)
9251 
      oprot.writeFieldEnd()
9253 rajveer 9252 
    if self.isAndroid is not None:
9253 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9254 
      oprot.writeBool(self.isAndroid)
9255 
      oprot.writeFieldEnd()
5944 mandeep.dh 9256 
    oprot.writeFieldStop()
9257 
    oprot.writeStructEnd()
9258 
 
9259 
  def validate(self):
9260 
    return
9261 
 
9262 
 
9263 
  def __repr__(self):
9264 
    L = ['%s=%r' % (key, value)
9265 
      for key, value in self.__dict__.iteritems()]
9266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9267 
 
9268 
  def __eq__(self, other):
9269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9270 
 
9271 
  def __ne__(self, other):
9272 
    return not (self == other)
9273 
 
9274 
class markItemAsContentComplete_result:
9275 
  """
9276 
  Attributes:
9277 
   - success
9278 
   - cex
9279 
  """
9280 
 
9281 
  thrift_spec = (
9282 
    (0, TType.BOOL, 'success', None, None, ), # 0
9283 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9284 
  )
9285 
 
9286 
  def __init__(self, success=None, cex=None,):
9287 
    self.success = success
9288 
    self.cex = cex
9289 
 
9290 
  def read(self, iprot):
9291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9293 
      return
9294 
    iprot.readStructBegin()
9295 
    while True:
9296 
      (fname, ftype, fid) = iprot.readFieldBegin()
9297 
      if ftype == TType.STOP:
9298 
        break
9299 
      if fid == 0:
9300 
        if ftype == TType.BOOL:
9301 
          self.success = iprot.readBool();
9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      elif fid == 1:
9305 
        if ftype == TType.STRUCT:
9306 
          self.cex = CatalogServiceException()
9307 
          self.cex.read(iprot)
9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      else:
9311 
        iprot.skip(ftype)
9312 
      iprot.readFieldEnd()
9313 
    iprot.readStructEnd()
9314 
 
9315 
  def write(self, oprot):
9316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9318 
      return
9319 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9320 
    if self.success is not None:
9321 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9322 
      oprot.writeBool(self.success)
9323 
      oprot.writeFieldEnd()
9324 
    if self.cex is not None:
9325 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9326 
      self.cex.write(oprot)
9327 
      oprot.writeFieldEnd()
9328 
    oprot.writeFieldStop()
9329 
    oprot.writeStructEnd()
9330 
 
9331 
  def validate(self):
9332 
    return
9333 
 
9334 
 
9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
9346 
class getAllItemsInRange_args:
9347 
  """
9348 
  Attributes:
9349 
   - offset
9350 
   - limit
9351 
  """
9352 
 
9353 
  thrift_spec = (
9354 
    None, # 0
9355 
    (1, TType.I64, 'offset', None, None, ), # 1
9356 
    (2, TType.I64, 'limit', None, None, ), # 2
9357 
  )
9358 
 
9359 
  def __init__(self, offset=None, limit=None,):
9360 
    self.offset = offset
9361 
    self.limit = limit
9362 
 
9363 
  def read(self, iprot):
9364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9366 
      return
9367 
    iprot.readStructBegin()
9368 
    while True:
9369 
      (fname, ftype, fid) = iprot.readFieldBegin()
9370 
      if ftype == TType.STOP:
9371 
        break
9372 
      if fid == 1:
9373 
        if ftype == TType.I64:
9374 
          self.offset = iprot.readI64();
9375 
        else:
9376 
          iprot.skip(ftype)
9377 
      elif fid == 2:
9378 
        if ftype == TType.I64:
9379 
          self.limit = iprot.readI64();
9380 
        else:
9381 
          iprot.skip(ftype)
9382 
      else:
9383 
        iprot.skip(ftype)
9384 
      iprot.readFieldEnd()
9385 
    iprot.readStructEnd()
9386 
 
9387 
  def write(self, oprot):
9388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9390 
      return
9391 
    oprot.writeStructBegin('getAllItemsInRange_args')
9392 
    if self.offset is not None:
9393 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9394 
      oprot.writeI64(self.offset)
9395 
      oprot.writeFieldEnd()
9396 
    if self.limit is not None:
9397 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9398 
      oprot.writeI64(self.limit)
9399 
      oprot.writeFieldEnd()
9400 
    oprot.writeFieldStop()
9401 
    oprot.writeStructEnd()
9402 
 
9403 
  def validate(self):
9404 
    return
9405 
 
9406 
 
9407 
  def __repr__(self):
9408 
    L = ['%s=%r' % (key, value)
9409 
      for key, value in self.__dict__.iteritems()]
9410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9411 
 
9412 
  def __eq__(self, other):
9413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9414 
 
9415 
  def __ne__(self, other):
9416 
    return not (self == other)
9417 
 
9418 
class getAllItemsInRange_result:
9419 
  """
9420 
  Attributes:
9421 
   - success
9422 
   - cex
9423 
  """
9424 
 
9425 
  thrift_spec = (
9426 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9427 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9428 
  )
9429 
 
9430 
  def __init__(self, success=None, cex=None,):
9431 
    self.success = success
9432 
    self.cex = cex
9433 
 
9434 
  def read(self, iprot):
9435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9437 
      return
9438 
    iprot.readStructBegin()
9439 
    while True:
9440 
      (fname, ftype, fid) = iprot.readFieldBegin()
9441 
      if ftype == TType.STOP:
9442 
        break
9443 
      if fid == 0:
9444 
        if ftype == TType.LIST:
9445 
          self.success = []
8590 kshitij.so 9446 
          (_etype77, _size74) = iprot.readListBegin()
9447 
          for _i78 in xrange(_size74):
9448 
            _elem79 = Item()
9449 
            _elem79.read(iprot)
9450 
            self.success.append(_elem79)
5944 mandeep.dh 9451 
          iprot.readListEnd()
9452 
        else:
9453 
          iprot.skip(ftype)
9454 
      elif fid == 1:
9455 
        if ftype == TType.STRUCT:
9456 
          self.cex = CatalogServiceException()
9457 
          self.cex.read(iprot)
9458 
        else:
9459 
          iprot.skip(ftype)
9460 
      else:
9461 
        iprot.skip(ftype)
9462 
      iprot.readFieldEnd()
9463 
    iprot.readStructEnd()
9464 
 
9465 
  def write(self, oprot):
9466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9468 
      return
9469 
    oprot.writeStructBegin('getAllItemsInRange_result')
9470 
    if self.success is not None:
9471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9473 
      for iter80 in self.success:
9474 
        iter80.write(oprot)
5944 mandeep.dh 9475 
      oprot.writeListEnd()
9476 
      oprot.writeFieldEnd()
9477 
    if self.cex is not None:
9478 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9479 
      self.cex.write(oprot)
9480 
      oprot.writeFieldEnd()
9481 
    oprot.writeFieldStop()
9482 
    oprot.writeStructEnd()
9483 
 
9484 
  def validate(self):
9485 
    return
9486 
 
9487 
 
9488 
  def __repr__(self):
9489 
    L = ['%s=%r' % (key, value)
9490 
      for key, value in self.__dict__.iteritems()]
9491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9492 
 
9493 
  def __eq__(self, other):
9494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9495 
 
9496 
  def __ne__(self, other):
9497 
    return not (self == other)
9498 
 
9499 
class getAllItemsByStatusInRange_args:
9500 
  """
9501 
  Attributes:
9502 
   - itemStatus
9503 
   - offset
9504 
   - limit
9505 
  """
9506 
 
9507 
  thrift_spec = (
9508 
    None, # 0
9509 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9510 
    (2, TType.I64, 'offset', None, None, ), # 2
9511 
    (3, TType.I64, 'limit', None, None, ), # 3
9512 
  )
9513 
 
9514 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9515 
    self.itemStatus = itemStatus
9516 
    self.offset = offset
9517 
    self.limit = limit
9518 
 
9519 
  def read(self, iprot):
9520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9522 
      return
9523 
    iprot.readStructBegin()
9524 
    while True:
9525 
      (fname, ftype, fid) = iprot.readFieldBegin()
9526 
      if ftype == TType.STOP:
9527 
        break
9528 
      if fid == 1:
9529 
        if ftype == TType.I32:
9530 
          self.itemStatus = iprot.readI32();
9531 
        else:
9532 
          iprot.skip(ftype)
9533 
      elif fid == 2:
9534 
        if ftype == TType.I64:
9535 
          self.offset = iprot.readI64();
9536 
        else:
9537 
          iprot.skip(ftype)
9538 
      elif fid == 3:
9539 
        if ftype == TType.I64:
9540 
          self.limit = iprot.readI64();
9541 
        else:
9542 
          iprot.skip(ftype)
9543 
      else:
9544 
        iprot.skip(ftype)
9545 
      iprot.readFieldEnd()
9546 
    iprot.readStructEnd()
9547 
 
9548 
  def write(self, oprot):
9549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9551 
      return
9552 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9553 
    if self.itemStatus is not None:
9554 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9555 
      oprot.writeI32(self.itemStatus)
9556 
      oprot.writeFieldEnd()
9557 
    if self.offset is not None:
9558 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9559 
      oprot.writeI64(self.offset)
9560 
      oprot.writeFieldEnd()
9561 
    if self.limit is not None:
9562 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9563 
      oprot.writeI64(self.limit)
9564 
      oprot.writeFieldEnd()
9565 
    oprot.writeFieldStop()
9566 
    oprot.writeStructEnd()
9567 
 
9568 
  def validate(self):
9569 
    return
9570 
 
9571 
 
9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
9583 
class getAllItemsByStatusInRange_result:
9584 
  """
9585 
  Attributes:
9586 
   - success
9587 
   - cex
9588 
  """
9589 
 
9590 
  thrift_spec = (
9591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9592 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9593 
  )
9594 
 
9595 
  def __init__(self, success=None, cex=None,):
9596 
    self.success = success
9597 
    self.cex = cex
9598 
 
9599 
  def read(self, iprot):
9600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9602 
      return
9603 
    iprot.readStructBegin()
9604 
    while True:
9605 
      (fname, ftype, fid) = iprot.readFieldBegin()
9606 
      if ftype == TType.STOP:
9607 
        break
9608 
      if fid == 0:
9609 
        if ftype == TType.LIST:
9610 
          self.success = []
8590 kshitij.so 9611 
          (_etype84, _size81) = iprot.readListBegin()
9612 
          for _i85 in xrange(_size81):
9613 
            _elem86 = Item()
9614 
            _elem86.read(iprot)
9615 
            self.success.append(_elem86)
5944 mandeep.dh 9616 
          iprot.readListEnd()
9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      elif fid == 1:
9620 
        if ftype == TType.STRUCT:
9621 
          self.cex = CatalogServiceException()
9622 
          self.cex.read(iprot)
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
9634 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9635 
    if self.success is not None:
9636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9638 
      for iter87 in self.success:
9639 
        iter87.write(oprot)
5944 mandeep.dh 9640 
      oprot.writeListEnd()
9641 
      oprot.writeFieldEnd()
9642 
    if self.cex is not None:
9643 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9644 
      self.cex.write(oprot)
9645 
      oprot.writeFieldEnd()
9646 
    oprot.writeFieldStop()
9647 
    oprot.writeStructEnd()
9648 
 
9649 
  def validate(self):
9650 
    return
9651 
 
9652 
 
9653 
  def __repr__(self):
9654 
    L = ['%s=%r' % (key, value)
9655 
      for key, value in self.__dict__.iteritems()]
9656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9657 
 
9658 
  def __eq__(self, other):
9659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9660 
 
9661 
  def __ne__(self, other):
9662 
    return not (self == other)
9663 
 
9664 
class getItemCountByStatus_args:
9665 
  """
9666 
  Attributes:
9667 
   - useStatus
9668 
   - itemStatus
9669 
  """
9670 
 
9671 
  thrift_spec = (
9672 
    None, # 0
9673 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9674 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9675 
  )
9676 
 
9677 
  def __init__(self, useStatus=None, itemStatus=None,):
9678 
    self.useStatus = useStatus
9679 
    self.itemStatus = itemStatus
9680 
 
9681 
  def read(self, iprot):
9682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9684 
      return
9685 
    iprot.readStructBegin()
9686 
    while True:
9687 
      (fname, ftype, fid) = iprot.readFieldBegin()
9688 
      if ftype == TType.STOP:
9689 
        break
9690 
      if fid == 1:
9691 
        if ftype == TType.BOOL:
9692 
          self.useStatus = iprot.readBool();
9693 
        else:
9694 
          iprot.skip(ftype)
9695 
      elif fid == 2:
9696 
        if ftype == TType.I32:
9697 
          self.itemStatus = iprot.readI32();
9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      else:
9701 
        iprot.skip(ftype)
9702 
      iprot.readFieldEnd()
9703 
    iprot.readStructEnd()
9704 
 
9705 
  def write(self, oprot):
9706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9708 
      return
9709 
    oprot.writeStructBegin('getItemCountByStatus_args')
9710 
    if self.useStatus is not None:
9711 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9712 
      oprot.writeBool(self.useStatus)
9713 
      oprot.writeFieldEnd()
9714 
    if self.itemStatus is not None:
9715 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9716 
      oprot.writeI32(self.itemStatus)
9717 
      oprot.writeFieldEnd()
9718 
    oprot.writeFieldStop()
9719 
    oprot.writeStructEnd()
9720 
 
9721 
  def validate(self):
9722 
    return
9723 
 
9724 
 
9725 
  def __repr__(self):
9726 
    L = ['%s=%r' % (key, value)
9727 
      for key, value in self.__dict__.iteritems()]
9728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9729 
 
9730 
  def __eq__(self, other):
9731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9732 
 
9733 
  def __ne__(self, other):
9734 
    return not (self == other)
9735 
 
9736 
class getItemCountByStatus_result:
9737 
  """
9738 
  Attributes:
9739 
   - success
9740 
  """
9741 
 
9742 
  thrift_spec = (
9743 
    (0, TType.I32, 'success', None, None, ), # 0
9744 
  )
9745 
 
9746 
  def __init__(self, success=None,):
9747 
    self.success = success
9748 
 
9749 
  def read(self, iprot):
9750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9752 
      return
9753 
    iprot.readStructBegin()
9754 
    while True:
9755 
      (fname, ftype, fid) = iprot.readFieldBegin()
9756 
      if ftype == TType.STOP:
9757 
        break
9758 
      if fid == 0:
9759 
        if ftype == TType.I32:
9760 
          self.success = iprot.readI32();
9761 
        else:
9762 
          iprot.skip(ftype)
9763 
      else:
9764 
        iprot.skip(ftype)
9765 
      iprot.readFieldEnd()
9766 
    iprot.readStructEnd()
9767 
 
9768 
  def write(self, oprot):
9769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9771 
      return
9772 
    oprot.writeStructBegin('getItemCountByStatus_result')
9773 
    if self.success is not None:
9774 
      oprot.writeFieldBegin('success', TType.I32, 0)
9775 
      oprot.writeI32(self.success)
9776 
      oprot.writeFieldEnd()
9777 
    oprot.writeFieldStop()
9778 
    oprot.writeStructEnd()
9779 
 
9780 
  def validate(self):
9781 
    return
9782 
 
9783 
 
9784 
  def __repr__(self):
9785 
    L = ['%s=%r' % (key, value)
9786 
      for key, value in self.__dict__.iteritems()]
9787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9788 
 
9789 
  def __eq__(self, other):
9790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9791 
 
9792 
  def __ne__(self, other):
9793 
    return not (self == other)
9794 
 
9795 
class getBestSellers_args:
9796 
 
9797 
  thrift_spec = (
9798 
  )
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      else:
9810 
        iprot.skip(ftype)
9811 
      iprot.readFieldEnd()
9812 
    iprot.readStructEnd()
9813 
 
9814 
  def write(self, oprot):
9815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9817 
      return
9818 
    oprot.writeStructBegin('getBestSellers_args')
9819 
    oprot.writeFieldStop()
9820 
    oprot.writeStructEnd()
9821 
 
9822 
  def validate(self):
9823 
    return
9824 
 
9825 
 
9826 
  def __repr__(self):
9827 
    L = ['%s=%r' % (key, value)
9828 
      for key, value in self.__dict__.iteritems()]
9829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9830 
 
9831 
  def __eq__(self, other):
9832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9833 
 
9834 
  def __ne__(self, other):
9835 
    return not (self == other)
9836 
 
9837 
class getBestSellers_result:
9838 
  """
9839 
  Attributes:
9840 
   - success
9841 
   - isex
9842 
  """
9843 
 
9844 
  thrift_spec = (
9845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9846 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9847 
  )
9848 
 
9849 
  def __init__(self, success=None, isex=None,):
9850 
    self.success = success
9851 
    self.isex = isex
9852 
 
9853 
  def read(self, iprot):
9854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9856 
      return
9857 
    iprot.readStructBegin()
9858 
    while True:
9859 
      (fname, ftype, fid) = iprot.readFieldBegin()
9860 
      if ftype == TType.STOP:
9861 
        break
9862 
      if fid == 0:
9863 
        if ftype == TType.LIST:
9864 
          self.success = []
8590 kshitij.so 9865 
          (_etype91, _size88) = iprot.readListBegin()
9866 
          for _i92 in xrange(_size88):
9867 
            _elem93 = Item()
9868 
            _elem93.read(iprot)
9869 
            self.success.append(_elem93)
5944 mandeep.dh 9870 
          iprot.readListEnd()
9871 
        else:
9872 
          iprot.skip(ftype)
9873 
      elif fid == 1:
9874 
        if ftype == TType.STRUCT:
9875 
          self.isex = CatalogServiceException()
9876 
          self.isex.read(iprot)
9877 
        else:
9878 
          iprot.skip(ftype)
9879 
      else:
9880 
        iprot.skip(ftype)
9881 
      iprot.readFieldEnd()
9882 
    iprot.readStructEnd()
9883 
 
9884 
  def write(self, oprot):
9885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9887 
      return
9888 
    oprot.writeStructBegin('getBestSellers_result')
9889 
    if self.success is not None:
9890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9892 
      for iter94 in self.success:
9893 
        iter94.write(oprot)
5944 mandeep.dh 9894 
      oprot.writeListEnd()
9895 
      oprot.writeFieldEnd()
9896 
    if self.isex is not None:
9897 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9898 
      self.isex.write(oprot)
9899 
      oprot.writeFieldEnd()
9900 
    oprot.writeFieldStop()
9901 
    oprot.writeStructEnd()
9902 
 
9903 
  def validate(self):
9904 
    return
9905 
 
9906 
 
9907 
  def __repr__(self):
9908 
    L = ['%s=%r' % (key, value)
9909 
      for key, value in self.__dict__.iteritems()]
9910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9911 
 
9912 
  def __eq__(self, other):
9913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9914 
 
9915 
  def __ne__(self, other):
9916 
    return not (self == other)
9917 
 
9918 
class getBestSellersCatalogIds_args:
9919 
  """
9920 
  Attributes:
9921 
   - beginIndex
9922 
   - totalItems
9923 
   - brand
9924 
   - category
9925 
  """
9926 
 
9927 
  thrift_spec = (
9928 
    None, # 0
9929 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9930 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9931 
    (3, TType.STRING, 'brand', None, None, ), # 3
9932 
    (4, TType.I64, 'category', None, None, ), # 4
9933 
  )
9934 
 
9935 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9936 
    self.beginIndex = beginIndex
9937 
    self.totalItems = totalItems
9938 
    self.brand = brand
9939 
    self.category = category
9940 
 
9941 
  def read(self, iprot):
9942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9944 
      return
9945 
    iprot.readStructBegin()
9946 
    while True:
9947 
      (fname, ftype, fid) = iprot.readFieldBegin()
9948 
      if ftype == TType.STOP:
9949 
        break
9950 
      if fid == 1:
9951 
        if ftype == TType.I64:
9952 
          self.beginIndex = iprot.readI64();
9953 
        else:
9954 
          iprot.skip(ftype)
9955 
      elif fid == 2:
9956 
        if ftype == TType.I64:
9957 
          self.totalItems = iprot.readI64();
9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      elif fid == 3:
9961 
        if ftype == TType.STRING:
9962 
          self.brand = iprot.readString();
9963 
        else:
9964 
          iprot.skip(ftype)
9965 
      elif fid == 4:
9966 
        if ftype == TType.I64:
9967 
          self.category = iprot.readI64();
9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      else:
9971 
        iprot.skip(ftype)
9972 
      iprot.readFieldEnd()
9973 
    iprot.readStructEnd()
9974 
 
9975 
  def write(self, oprot):
9976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9978 
      return
9979 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9980 
    if self.beginIndex is not None:
9981 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9982 
      oprot.writeI64(self.beginIndex)
9983 
      oprot.writeFieldEnd()
9984 
    if self.totalItems is not None:
9985 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9986 
      oprot.writeI64(self.totalItems)
9987 
      oprot.writeFieldEnd()
9988 
    if self.brand is not None:
9989 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9990 
      oprot.writeString(self.brand)
9991 
      oprot.writeFieldEnd()
9992 
    if self.category is not None:
9993 
      oprot.writeFieldBegin('category', TType.I64, 4)
9994 
      oprot.writeI64(self.category)
9995 
      oprot.writeFieldEnd()
9996 
    oprot.writeFieldStop()
9997 
    oprot.writeStructEnd()
9998 
 
9999 
  def validate(self):
10000 
    return
10001 
 
10002 
 
10003 
  def __repr__(self):
10004 
    L = ['%s=%r' % (key, value)
10005 
      for key, value in self.__dict__.iteritems()]
10006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10007 
 
10008 
  def __eq__(self, other):
10009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10010 
 
10011 
  def __ne__(self, other):
10012 
    return not (self == other)
10013 
 
10014 
class getBestSellersCatalogIds_result:
10015 
  """
10016 
  Attributes:
10017 
   - success
10018 
   - cex
10019 
  """
10020 
 
10021 
  thrift_spec = (
10022 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10023 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10024 
  )
10025 
 
10026 
  def __init__(self, success=None, cex=None,):
10027 
    self.success = success
10028 
    self.cex = cex
10029 
 
10030 
  def read(self, iprot):
10031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10033 
      return
10034 
    iprot.readStructBegin()
10035 
    while True:
10036 
      (fname, ftype, fid) = iprot.readFieldBegin()
10037 
      if ftype == TType.STOP:
10038 
        break
10039 
      if fid == 0:
10040 
        if ftype == TType.LIST:
10041 
          self.success = []
8590 kshitij.so 10042 
          (_etype98, _size95) = iprot.readListBegin()
10043 
          for _i99 in xrange(_size95):
10044 
            _elem100 = iprot.readI64();
10045 
            self.success.append(_elem100)
5944 mandeep.dh 10046 
          iprot.readListEnd()
10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      elif fid == 1:
10050 
        if ftype == TType.STRUCT:
10051 
          self.cex = CatalogServiceException()
10052 
          self.cex.read(iprot)
10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      else:
10056 
        iprot.skip(ftype)
10057 
      iprot.readFieldEnd()
10058 
    iprot.readStructEnd()
10059 
 
10060 
  def write(self, oprot):
10061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10063 
      return
10064 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10065 
    if self.success is not None:
10066 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10067 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10068 
      for iter101 in self.success:
10069 
        oprot.writeI64(iter101)
5944 mandeep.dh 10070 
      oprot.writeListEnd()
10071 
      oprot.writeFieldEnd()
10072 
    if self.cex is not None:
10073 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10074 
      self.cex.write(oprot)
10075 
      oprot.writeFieldEnd()
10076 
    oprot.writeFieldStop()
10077 
    oprot.writeStructEnd()
10078 
 
10079 
  def validate(self):
10080 
    return
10081 
 
10082 
 
10083 
  def __repr__(self):
10084 
    L = ['%s=%r' % (key, value)
10085 
      for key, value in self.__dict__.iteritems()]
10086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10087 
 
10088 
  def __eq__(self, other):
10089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10090 
 
10091 
  def __ne__(self, other):
10092 
    return not (self == other)
10093 
 
10094 
class getBestSellersCount_args:
10095 
 
10096 
  thrift_spec = (
10097 
  )
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
10117 
    oprot.writeStructBegin('getBestSellersCount_args')
10118 
    oprot.writeFieldStop()
10119 
    oprot.writeStructEnd()
10120 
 
10121 
  def validate(self):
10122 
    return
10123 
 
10124 
 
10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
10136 
class getBestSellersCount_result:
10137 
  """
10138 
  Attributes:
10139 
   - success
10140 
   - cex
10141 
  """
10142 
 
10143 
  thrift_spec = (
10144 
    (0, TType.I64, 'success', None, None, ), # 0
10145 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10146 
  )
10147 
 
10148 
  def __init__(self, success=None, cex=None,):
10149 
    self.success = success
10150 
    self.cex = cex
10151 
 
10152 
  def read(self, iprot):
10153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10155 
      return
10156 
    iprot.readStructBegin()
10157 
    while True:
10158 
      (fname, ftype, fid) = iprot.readFieldBegin()
10159 
      if ftype == TType.STOP:
10160 
        break
10161 
      if fid == 0:
10162 
        if ftype == TType.I64:
10163 
          self.success = iprot.readI64();
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      elif fid == 1:
10167 
        if ftype == TType.STRUCT:
10168 
          self.cex = CatalogServiceException()
10169 
          self.cex.read(iprot)
10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      else:
10173 
        iprot.skip(ftype)
10174 
      iprot.readFieldEnd()
10175 
    iprot.readStructEnd()
10176 
 
10177 
  def write(self, oprot):
10178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10180 
      return
10181 
    oprot.writeStructBegin('getBestSellersCount_result')
10182 
    if self.success is not None:
10183 
      oprot.writeFieldBegin('success', TType.I64, 0)
10184 
      oprot.writeI64(self.success)
10185 
      oprot.writeFieldEnd()
10186 
    if self.cex is not None:
10187 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10188 
      self.cex.write(oprot)
10189 
      oprot.writeFieldEnd()
10190 
    oprot.writeFieldStop()
10191 
    oprot.writeStructEnd()
10192 
 
10193 
  def validate(self):
10194 
    return
10195 
 
10196 
 
10197 
  def __repr__(self):
10198 
    L = ['%s=%r' % (key, value)
10199 
      for key, value in self.__dict__.iteritems()]
10200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10201 
 
10202 
  def __eq__(self, other):
10203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10204 
 
10205 
  def __ne__(self, other):
10206 
    return not (self == other)
10207 
 
10208 
class getBestDeals_args:
10209 
 
10210 
  thrift_spec = (
10211 
  )
10212 
 
10213 
  def read(self, iprot):
10214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10216 
      return
10217 
    iprot.readStructBegin()
10218 
    while True:
10219 
      (fname, ftype, fid) = iprot.readFieldBegin()
10220 
      if ftype == TType.STOP:
10221 
        break
10222 
      else:
10223 
        iprot.skip(ftype)
10224 
      iprot.readFieldEnd()
10225 
    iprot.readStructEnd()
10226 
 
10227 
  def write(self, oprot):
10228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10230 
      return
10231 
    oprot.writeStructBegin('getBestDeals_args')
10232 
    oprot.writeFieldStop()
10233 
    oprot.writeStructEnd()
10234 
 
10235 
  def validate(self):
10236 
    return
10237 
 
10238 
 
10239 
  def __repr__(self):
10240 
    L = ['%s=%r' % (key, value)
10241 
      for key, value in self.__dict__.iteritems()]
10242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10243 
 
10244 
  def __eq__(self, other):
10245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10246 
 
10247 
  def __ne__(self, other):
10248 
    return not (self == other)
10249 
 
10250 
class getBestDeals_result:
10251 
  """
10252 
  Attributes:
10253 
   - success
10254 
   - isex
10255 
  """
10256 
 
10257 
  thrift_spec = (
10258 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10259 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10260 
  )
10261 
 
10262 
  def __init__(self, success=None, isex=None,):
10263 
    self.success = success
10264 
    self.isex = isex
10265 
 
10266 
  def read(self, iprot):
10267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10269 
      return
10270 
    iprot.readStructBegin()
10271 
    while True:
10272 
      (fname, ftype, fid) = iprot.readFieldBegin()
10273 
      if ftype == TType.STOP:
10274 
        break
10275 
      if fid == 0:
10276 
        if ftype == TType.LIST:
10277 
          self.success = []
8590 kshitij.so 10278 
          (_etype105, _size102) = iprot.readListBegin()
10279 
          for _i106 in xrange(_size102):
10280 
            _elem107 = Item()
10281 
            _elem107.read(iprot)
10282 
            self.success.append(_elem107)
5944 mandeep.dh 10283 
          iprot.readListEnd()
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      elif fid == 1:
10287 
        if ftype == TType.STRUCT:
10288 
          self.isex = CatalogServiceException()
10289 
          self.isex.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('getBestDeals_result')
10302 
    if self.success is not None:
10303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10304 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10305 
      for iter108 in self.success:
10306 
        iter108.write(oprot)
5944 mandeep.dh 10307 
      oprot.writeListEnd()
10308 
      oprot.writeFieldEnd()
10309 
    if self.isex is not None:
10310 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10311 
      self.isex.write(oprot)
10312 
      oprot.writeFieldEnd()
10313 
    oprot.writeFieldStop()
10314 
    oprot.writeStructEnd()
10315 
 
10316 
  def validate(self):
10317 
    return
10318 
 
10319 
 
10320 
  def __repr__(self):
10321 
    L = ['%s=%r' % (key, value)
10322 
      for key, value in self.__dict__.iteritems()]
10323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10324 
 
10325 
  def __eq__(self, other):
10326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10327 
 
10328 
  def __ne__(self, other):
10329 
    return not (self == other)
10330 
 
10331 
class getBestDealsCatalogIds_args:
10332 
  """
10333 
  Attributes:
10334 
   - beginIndex
10335 
   - totalItems
10336 
   - brand
10337 
   - category
10338 
  """
10339 
 
10340 
  thrift_spec = (
10341 
    None, # 0
10342 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10343 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10344 
    (3, TType.STRING, 'brand', None, None, ), # 3
10345 
    (4, TType.I64, 'category', None, None, ), # 4
10346 
  )
10347 
 
10348 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10349 
    self.beginIndex = beginIndex
10350 
    self.totalItems = totalItems
10351 
    self.brand = brand
10352 
    self.category = category
10353 
 
10354 
  def read(self, iprot):
10355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10357 
      return
10358 
    iprot.readStructBegin()
10359 
    while True:
10360 
      (fname, ftype, fid) = iprot.readFieldBegin()
10361 
      if ftype == TType.STOP:
10362 
        break
10363 
      if fid == 1:
10364 
        if ftype == TType.I64:
10365 
          self.beginIndex = iprot.readI64();
10366 
        else:
10367 
          iprot.skip(ftype)
10368 
      elif fid == 2:
10369 
        if ftype == TType.I64:
10370 
          self.totalItems = iprot.readI64();
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      elif fid == 3:
10374 
        if ftype == TType.STRING:
10375 
          self.brand = iprot.readString();
10376 
        else:
10377 
          iprot.skip(ftype)
10378 
      elif fid == 4:
10379 
        if ftype == TType.I64:
10380 
          self.category = iprot.readI64();
10381 
        else:
10382 
          iprot.skip(ftype)
10383 
      else:
10384 
        iprot.skip(ftype)
10385 
      iprot.readFieldEnd()
10386 
    iprot.readStructEnd()
10387 
 
10388 
  def write(self, oprot):
10389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10391 
      return
10392 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10393 
    if self.beginIndex is not None:
10394 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10395 
      oprot.writeI64(self.beginIndex)
10396 
      oprot.writeFieldEnd()
10397 
    if self.totalItems is not None:
10398 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10399 
      oprot.writeI64(self.totalItems)
10400 
      oprot.writeFieldEnd()
10401 
    if self.brand is not None:
10402 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10403 
      oprot.writeString(self.brand)
10404 
      oprot.writeFieldEnd()
10405 
    if self.category is not None:
10406 
      oprot.writeFieldBegin('category', TType.I64, 4)
10407 
      oprot.writeI64(self.category)
10408 
      oprot.writeFieldEnd()
10409 
    oprot.writeFieldStop()
10410 
    oprot.writeStructEnd()
10411 
 
10412 
  def validate(self):
10413 
    return
10414 
 
10415 
 
10416 
  def __repr__(self):
10417 
    L = ['%s=%r' % (key, value)
10418 
      for key, value in self.__dict__.iteritems()]
10419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10420 
 
10421 
  def __eq__(self, other):
10422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10423 
 
10424 
  def __ne__(self, other):
10425 
    return not (self == other)
10426 
 
10427 
class getBestDealsCatalogIds_result:
10428 
  """
10429 
  Attributes:
10430 
   - success
10431 
   - cex
10432 
  """
10433 
 
10434 
  thrift_spec = (
10435 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10436 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10437 
  )
10438 
 
10439 
  def __init__(self, success=None, cex=None,):
10440 
    self.success = success
10441 
    self.cex = cex
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 == 0:
10453 
        if ftype == TType.LIST:
10454 
          self.success = []
8590 kshitij.so 10455 
          (_etype112, _size109) = iprot.readListBegin()
10456 
          for _i113 in xrange(_size109):
10457 
            _elem114 = iprot.readI64();
10458 
            self.success.append(_elem114)
5944 mandeep.dh 10459 
          iprot.readListEnd()
10460 
        else:
10461 
          iprot.skip(ftype)
10462 
      elif fid == 1:
10463 
        if ftype == TType.STRUCT:
10464 
          self.cex = CatalogServiceException()
10465 
          self.cex.read(iprot)
10466 
        else:
10467 
          iprot.skip(ftype)
10468 
      else:
10469 
        iprot.skip(ftype)
10470 
      iprot.readFieldEnd()
10471 
    iprot.readStructEnd()
10472 
 
10473 
  def write(self, oprot):
10474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10476 
      return
10477 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10478 
    if self.success is not None:
10479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10480 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10481 
      for iter115 in self.success:
10482 
        oprot.writeI64(iter115)
5944 mandeep.dh 10483 
      oprot.writeListEnd()
10484 
      oprot.writeFieldEnd()
10485 
    if self.cex is not None:
10486 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10487 
      self.cex.write(oprot)
10488 
      oprot.writeFieldEnd()
10489 
    oprot.writeFieldStop()
10490 
    oprot.writeStructEnd()
10491 
 
10492 
  def validate(self):
10493 
    return
10494 
 
10495 
 
10496 
  def __repr__(self):
10497 
    L = ['%s=%r' % (key, value)
10498 
      for key, value in self.__dict__.iteritems()]
10499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10500 
 
10501 
  def __eq__(self, other):
10502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10503 
 
10504 
  def __ne__(self, other):
10505 
    return not (self == other)
10506 
 
10507 
class getBestDealsCount_args:
10508 
 
10509 
  thrift_spec = (
10510 
  )
10511 
 
10512 
  def read(self, iprot):
10513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10515 
      return
10516 
    iprot.readStructBegin()
10517 
    while True:
10518 
      (fname, ftype, fid) = iprot.readFieldBegin()
10519 
      if ftype == TType.STOP:
10520 
        break
10521 
      else:
10522 
        iprot.skip(ftype)
10523 
      iprot.readFieldEnd()
10524 
    iprot.readStructEnd()
10525 
 
10526 
  def write(self, oprot):
10527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10529 
      return
10530 
    oprot.writeStructBegin('getBestDealsCount_args')
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 getBestDealsCount_result:
10550 
  """
10551 
  Attributes:
10552 
   - success
10553 
   - cex
10554 
  """
10555 
 
10556 
  thrift_spec = (
10557 
    (0, TType.I64, 'success', None, None, ), # 0
10558 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10559 
  )
10560 
 
10561 
  def __init__(self, success=None, cex=None,):
10562 
    self.success = success
10563 
    self.cex = cex
10564 
 
10565 
  def read(self, iprot):
10566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10568 
      return
10569 
    iprot.readStructBegin()
10570 
    while True:
10571 
      (fname, ftype, fid) = iprot.readFieldBegin()
10572 
      if ftype == TType.STOP:
10573 
        break
10574 
      if fid == 0:
10575 
        if ftype == TType.I64:
10576 
          self.success = iprot.readI64();
10577 
        else:
10578 
          iprot.skip(ftype)
10579 
      elif fid == 1:
10580 
        if ftype == TType.STRUCT:
10581 
          self.cex = CatalogServiceException()
10582 
          self.cex.read(iprot)
10583 
        else:
10584 
          iprot.skip(ftype)
10585 
      else:
10586 
        iprot.skip(ftype)
10587 
      iprot.readFieldEnd()
10588 
    iprot.readStructEnd()
10589 
 
10590 
  def write(self, oprot):
10591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10593 
      return
10594 
    oprot.writeStructBegin('getBestDealsCount_result')
10595 
    if self.success is not None:
10596 
      oprot.writeFieldBegin('success', TType.I64, 0)
10597 
      oprot.writeI64(self.success)
10598 
      oprot.writeFieldEnd()
10599 
    if self.cex is not None:
10600 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10601 
      self.cex.write(oprot)
10602 
      oprot.writeFieldEnd()
10603 
    oprot.writeFieldStop()
10604 
    oprot.writeStructEnd()
10605 
 
10606 
  def validate(self):
10607 
    return
10608 
 
10609 
 
10610 
  def __repr__(self):
10611 
    L = ['%s=%r' % (key, value)
10612 
      for key, value in self.__dict__.iteritems()]
10613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10614 
 
10615 
  def __eq__(self, other):
10616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10617 
 
10618 
  def __ne__(self, other):
10619 
    return not (self == other)
10620 
 
10621 
class getComingSoon_args:
10622 
 
10623 
  thrift_spec = (
10624 
  )
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      else:
10636 
        iprot.skip(ftype)
10637 
      iprot.readFieldEnd()
10638 
    iprot.readStructEnd()
10639 
 
10640 
  def write(self, oprot):
10641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10643 
      return
10644 
    oprot.writeStructBegin('getComingSoon_args')
10645 
    oprot.writeFieldStop()
10646 
    oprot.writeStructEnd()
10647 
 
10648 
  def validate(self):
10649 
    return
10650 
 
10651 
 
10652 
  def __repr__(self):
10653 
    L = ['%s=%r' % (key, value)
10654 
      for key, value in self.__dict__.iteritems()]
10655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10656 
 
10657 
  def __eq__(self, other):
10658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10659 
 
10660 
  def __ne__(self, other):
10661 
    return not (self == other)
10662 
 
10663 
class getComingSoon_result:
10664 
  """
10665 
  Attributes:
10666 
   - success
10667 
   - isex
10668 
  """
10669 
 
10670 
  thrift_spec = (
10671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10672 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10673 
  )
10674 
 
10675 
  def __init__(self, success=None, isex=None,):
10676 
    self.success = success
10677 
    self.isex = isex
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 0:
10689 
        if ftype == TType.LIST:
10690 
          self.success = []
8590 kshitij.so 10691 
          (_etype119, _size116) = iprot.readListBegin()
10692 
          for _i120 in xrange(_size116):
10693 
            _elem121 = Item()
10694 
            _elem121.read(iprot)
10695 
            self.success.append(_elem121)
5944 mandeep.dh 10696 
          iprot.readListEnd()
10697 
        else:
10698 
          iprot.skip(ftype)
10699 
      elif fid == 1:
10700 
        if ftype == TType.STRUCT:
10701 
          self.isex = CatalogServiceException()
10702 
          self.isex.read(iprot)
10703 
        else:
10704 
          iprot.skip(ftype)
10705 
      else:
10706 
        iprot.skip(ftype)
10707 
      iprot.readFieldEnd()
10708 
    iprot.readStructEnd()
10709 
 
10710 
  def write(self, oprot):
10711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10713 
      return
10714 
    oprot.writeStructBegin('getComingSoon_result')
10715 
    if self.success is not None:
10716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10718 
      for iter122 in self.success:
10719 
        iter122.write(oprot)
5944 mandeep.dh 10720 
      oprot.writeListEnd()
10721 
      oprot.writeFieldEnd()
10722 
    if self.isex is not None:
10723 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10724 
      self.isex.write(oprot)
10725 
      oprot.writeFieldEnd()
10726 
    oprot.writeFieldStop()
10727 
    oprot.writeStructEnd()
10728 
 
10729 
  def validate(self):
10730 
    return
10731 
 
10732 
 
10733 
  def __repr__(self):
10734 
    L = ['%s=%r' % (key, value)
10735 
      for key, value in self.__dict__.iteritems()]
10736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10737 
 
10738 
  def __eq__(self, other):
10739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10740 
 
10741 
  def __ne__(self, other):
10742 
    return not (self == other)
10743 
 
10744 
class getComingSoonCatalogIds_args:
10745 
  """
10746 
  Attributes:
10747 
   - beginIndex
10748 
   - totalItems
10749 
   - brand
10750 
   - category
10751 
  """
10752 
 
10753 
  thrift_spec = (
10754 
    None, # 0
10755 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10756 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10757 
    (3, TType.STRING, 'brand', None, None, ), # 3
10758 
    (4, TType.I64, 'category', None, None, ), # 4
10759 
  )
10760 
 
10761 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10762 
    self.beginIndex = beginIndex
10763 
    self.totalItems = totalItems
10764 
    self.brand = brand
10765 
    self.category = category
10766 
 
10767 
  def read(self, iprot):
10768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10770 
      return
10771 
    iprot.readStructBegin()
10772 
    while True:
10773 
      (fname, ftype, fid) = iprot.readFieldBegin()
10774 
      if ftype == TType.STOP:
10775 
        break
10776 
      if fid == 1:
10777 
        if ftype == TType.I64:
10778 
          self.beginIndex = iprot.readI64();
10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      elif fid == 2:
10782 
        if ftype == TType.I64:
10783 
          self.totalItems = iprot.readI64();
10784 
        else:
10785 
          iprot.skip(ftype)
10786 
      elif fid == 3:
10787 
        if ftype == TType.STRING:
10788 
          self.brand = iprot.readString();
10789 
        else:
10790 
          iprot.skip(ftype)
10791 
      elif fid == 4:
10792 
        if ftype == TType.I64:
10793 
          self.category = iprot.readI64();
10794 
        else:
10795 
          iprot.skip(ftype)
10796 
      else:
10797 
        iprot.skip(ftype)
10798 
      iprot.readFieldEnd()
10799 
    iprot.readStructEnd()
10800 
 
10801 
  def write(self, oprot):
10802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10804 
      return
10805 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10806 
    if self.beginIndex is not None:
10807 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10808 
      oprot.writeI64(self.beginIndex)
10809 
      oprot.writeFieldEnd()
10810 
    if self.totalItems is not None:
10811 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10812 
      oprot.writeI64(self.totalItems)
10813 
      oprot.writeFieldEnd()
10814 
    if self.brand is not None:
10815 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10816 
      oprot.writeString(self.brand)
10817 
      oprot.writeFieldEnd()
10818 
    if self.category is not None:
10819 
      oprot.writeFieldBegin('category', TType.I64, 4)
10820 
      oprot.writeI64(self.category)
10821 
      oprot.writeFieldEnd()
10822 
    oprot.writeFieldStop()
10823 
    oprot.writeStructEnd()
10824 
 
10825 
  def validate(self):
10826 
    return
10827 
 
10828 
 
10829 
  def __repr__(self):
10830 
    L = ['%s=%r' % (key, value)
10831 
      for key, value in self.__dict__.iteritems()]
10832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10833 
 
10834 
  def __eq__(self, other):
10835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10836 
 
10837 
  def __ne__(self, other):
10838 
    return not (self == other)
10839 
 
10840 
class getComingSoonCatalogIds_result:
10841 
  """
10842 
  Attributes:
10843 
   - success
10844 
   - cex
10845 
  """
10846 
 
10847 
  thrift_spec = (
10848 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10849 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10850 
  )
10851 
 
10852 
  def __init__(self, success=None, cex=None,):
10853 
    self.success = success
10854 
    self.cex = cex
10855 
 
10856 
  def read(self, iprot):
10857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10859 
      return
10860 
    iprot.readStructBegin()
10861 
    while True:
10862 
      (fname, ftype, fid) = iprot.readFieldBegin()
10863 
      if ftype == TType.STOP:
10864 
        break
10865 
      if fid == 0:
10866 
        if ftype == TType.LIST:
10867 
          self.success = []
8590 kshitij.so 10868 
          (_etype126, _size123) = iprot.readListBegin()
10869 
          for _i127 in xrange(_size123):
10870 
            _elem128 = iprot.readI64();
10871 
            self.success.append(_elem128)
5944 mandeep.dh 10872 
          iprot.readListEnd()
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      elif fid == 1:
10876 
        if ftype == TType.STRUCT:
10877 
          self.cex = CatalogServiceException()
10878 
          self.cex.read(iprot)
10879 
        else:
10880 
          iprot.skip(ftype)
10881 
      else:
10882 
        iprot.skip(ftype)
10883 
      iprot.readFieldEnd()
10884 
    iprot.readStructEnd()
10885 
 
10886 
  def write(self, oprot):
10887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10889 
      return
10890 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10891 
    if self.success is not None:
10892 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10893 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10894 
      for iter129 in self.success:
10895 
        oprot.writeI64(iter129)
5944 mandeep.dh 10896 
      oprot.writeListEnd()
10897 
      oprot.writeFieldEnd()
10898 
    if self.cex is not None:
10899 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10900 
      self.cex.write(oprot)
10901 
      oprot.writeFieldEnd()
10902 
    oprot.writeFieldStop()
10903 
    oprot.writeStructEnd()
10904 
 
10905 
  def validate(self):
10906 
    return
10907 
 
10908 
 
10909 
  def __repr__(self):
10910 
    L = ['%s=%r' % (key, value)
10911 
      for key, value in self.__dict__.iteritems()]
10912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10913 
 
10914 
  def __eq__(self, other):
10915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10916 
 
10917 
  def __ne__(self, other):
10918 
    return not (self == other)
10919 
 
10920 
class getComingSoonCount_args:
10921 
 
10922 
  thrift_spec = (
10923 
  )
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      else:
10935 
        iprot.skip(ftype)
10936 
      iprot.readFieldEnd()
10937 
    iprot.readStructEnd()
10938 
 
10939 
  def write(self, oprot):
10940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10942 
      return
10943 
    oprot.writeStructBegin('getComingSoonCount_args')
10944 
    oprot.writeFieldStop()
10945 
    oprot.writeStructEnd()
10946 
 
10947 
  def validate(self):
10948 
    return
10949 
 
10950 
 
10951 
  def __repr__(self):
10952 
    L = ['%s=%r' % (key, value)
10953 
      for key, value in self.__dict__.iteritems()]
10954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10955 
 
10956 
  def __eq__(self, other):
10957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10958 
 
10959 
  def __ne__(self, other):
10960 
    return not (self == other)
10961 
 
10962 
class getComingSoonCount_result:
10963 
  """
10964 
  Attributes:
10965 
   - success
10966 
   - cex
10967 
  """
10968 
 
10969 
  thrift_spec = (
10970 
    (0, TType.I64, 'success', None, None, ), # 0
10971 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10972 
  )
10973 
 
10974 
  def __init__(self, success=None, cex=None,):
10975 
    self.success = success
10976 
    self.cex = cex
10977 
 
10978 
  def read(self, iprot):
10979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10981 
      return
10982 
    iprot.readStructBegin()
10983 
    while True:
10984 
      (fname, ftype, fid) = iprot.readFieldBegin()
10985 
      if ftype == TType.STOP:
10986 
        break
10987 
      if fid == 0:
10988 
        if ftype == TType.I64:
10989 
          self.success = iprot.readI64();
10990 
        else:
10991 
          iprot.skip(ftype)
10992 
      elif fid == 1:
10993 
        if ftype == TType.STRUCT:
10994 
          self.cex = CatalogServiceException()
10995 
          self.cex.read(iprot)
10996 
        else:
10997 
          iprot.skip(ftype)
10998 
      else:
10999 
        iprot.skip(ftype)
11000 
      iprot.readFieldEnd()
11001 
    iprot.readStructEnd()
11002 
 
11003 
  def write(self, oprot):
11004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11006 
      return
11007 
    oprot.writeStructBegin('getComingSoonCount_result')
11008 
    if self.success is not None:
11009 
      oprot.writeFieldBegin('success', TType.I64, 0)
11010 
      oprot.writeI64(self.success)
11011 
      oprot.writeFieldEnd()
11012 
    if self.cex is not None:
11013 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11014 
      self.cex.write(oprot)
11015 
      oprot.writeFieldEnd()
11016 
    oprot.writeFieldStop()
11017 
    oprot.writeStructEnd()
11018 
 
11019 
  def validate(self):
11020 
    return
11021 
 
11022 
 
11023 
  def __repr__(self):
11024 
    L = ['%s=%r' % (key, value)
11025 
      for key, value in self.__dict__.iteritems()]
11026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11027 
 
11028 
  def __eq__(self, other):
11029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11030 
 
11031 
  def __ne__(self, other):
11032 
    return not (self == other)
11033 
 
11034 
class getLatestArrivals_args:
11035 
 
11036 
  thrift_spec = (
11037 
  )
11038 
 
11039 
  def read(self, iprot):
11040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11042 
      return
11043 
    iprot.readStructBegin()
11044 
    while True:
11045 
      (fname, ftype, fid) = iprot.readFieldBegin()
11046 
      if ftype == TType.STOP:
11047 
        break
11048 
      else:
11049 
        iprot.skip(ftype)
11050 
      iprot.readFieldEnd()
11051 
    iprot.readStructEnd()
11052 
 
11053 
  def write(self, oprot):
11054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11056 
      return
11057 
    oprot.writeStructBegin('getLatestArrivals_args')
11058 
    oprot.writeFieldStop()
11059 
    oprot.writeStructEnd()
11060 
 
11061 
  def validate(self):
11062 
    return
11063 
 
11064 
 
11065 
  def __repr__(self):
11066 
    L = ['%s=%r' % (key, value)
11067 
      for key, value in self.__dict__.iteritems()]
11068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11069 
 
11070 
  def __eq__(self, other):
11071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11072 
 
11073 
  def __ne__(self, other):
11074 
    return not (self == other)
11075 
 
11076 
class getLatestArrivals_result:
11077 
  """
11078 
  Attributes:
11079 
   - success
11080 
   - isex
11081 
  """
11082 
 
11083 
  thrift_spec = (
11084 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11085 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11086 
  )
11087 
 
11088 
  def __init__(self, success=None, isex=None,):
11089 
    self.success = success
11090 
    self.isex = isex
11091 
 
11092 
  def read(self, iprot):
11093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11095 
      return
11096 
    iprot.readStructBegin()
11097 
    while True:
11098 
      (fname, ftype, fid) = iprot.readFieldBegin()
11099 
      if ftype == TType.STOP:
11100 
        break
11101 
      if fid == 0:
11102 
        if ftype == TType.LIST:
11103 
          self.success = []
8590 kshitij.so 11104 
          (_etype133, _size130) = iprot.readListBegin()
11105 
          for _i134 in xrange(_size130):
11106 
            _elem135 = Item()
11107 
            _elem135.read(iprot)
11108 
            self.success.append(_elem135)
5944 mandeep.dh 11109 
          iprot.readListEnd()
11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      elif fid == 1:
11113 
        if ftype == TType.STRUCT:
11114 
          self.isex = CatalogServiceException()
11115 
          self.isex.read(iprot)
11116 
        else:
11117 
          iprot.skip(ftype)
11118 
      else:
11119 
        iprot.skip(ftype)
11120 
      iprot.readFieldEnd()
11121 
    iprot.readStructEnd()
11122 
 
11123 
  def write(self, oprot):
11124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11126 
      return
11127 
    oprot.writeStructBegin('getLatestArrivals_result')
11128 
    if self.success is not None:
11129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11130 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11131 
      for iter136 in self.success:
11132 
        iter136.write(oprot)
5944 mandeep.dh 11133 
      oprot.writeListEnd()
11134 
      oprot.writeFieldEnd()
11135 
    if self.isex is not None:
11136 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11137 
      self.isex.write(oprot)
11138 
      oprot.writeFieldEnd()
11139 
    oprot.writeFieldStop()
11140 
    oprot.writeStructEnd()
11141 
 
11142 
  def validate(self):
11143 
    return
11144 
 
11145 
 
11146 
  def __repr__(self):
11147 
    L = ['%s=%r' % (key, value)
11148 
      for key, value in self.__dict__.iteritems()]
11149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11150 
 
11151 
  def __eq__(self, other):
11152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11153 
 
11154 
  def __ne__(self, other):
11155 
    return not (self == other)
11156 
 
11157 
class getLatestArrivalsCatalogIds_args:
11158 
  """
11159 
  Attributes:
11160 
   - beginIndex
11161 
   - totalItems
11162 
   - brand
11163 
   - categories
11164 
  """
11165 
 
11166 
  thrift_spec = (
11167 
    None, # 0
11168 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11169 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11170 
    (3, TType.STRING, 'brand', None, None, ), # 3
11171 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11172 
  )
11173 
 
11174 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11175 
    self.beginIndex = beginIndex
11176 
    self.totalItems = totalItems
11177 
    self.brand = brand
11178 
    self.categories = categories
11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      if fid == 1:
11190 
        if ftype == TType.I64:
11191 
          self.beginIndex = iprot.readI64();
11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      elif fid == 2:
11195 
        if ftype == TType.I64:
11196 
          self.totalItems = iprot.readI64();
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      elif fid == 3:
11200 
        if ftype == TType.STRING:
11201 
          self.brand = iprot.readString();
11202 
        else:
11203 
          iprot.skip(ftype)
11204 
      elif fid == 4:
11205 
        if ftype == TType.LIST:
11206 
          self.categories = []
8590 kshitij.so 11207 
          (_etype140, _size137) = iprot.readListBegin()
11208 
          for _i141 in xrange(_size137):
11209 
            _elem142 = iprot.readI64();
11210 
            self.categories.append(_elem142)
5944 mandeep.dh 11211 
          iprot.readListEnd()
11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      else:
11215 
        iprot.skip(ftype)
11216 
      iprot.readFieldEnd()
11217 
    iprot.readStructEnd()
11218 
 
11219 
  def write(self, oprot):
11220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11222 
      return
11223 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11224 
    if self.beginIndex is not None:
11225 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11226 
      oprot.writeI64(self.beginIndex)
11227 
      oprot.writeFieldEnd()
11228 
    if self.totalItems is not None:
11229 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11230 
      oprot.writeI64(self.totalItems)
11231 
      oprot.writeFieldEnd()
11232 
    if self.brand is not None:
11233 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11234 
      oprot.writeString(self.brand)
11235 
      oprot.writeFieldEnd()
11236 
    if self.categories is not None:
11237 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11238 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11239 
      for iter143 in self.categories:
11240 
        oprot.writeI64(iter143)
5944 mandeep.dh 11241 
      oprot.writeListEnd()
11242 
      oprot.writeFieldEnd()
11243 
    oprot.writeFieldStop()
11244 
    oprot.writeStructEnd()
11245 
 
11246 
  def validate(self):
11247 
    return
11248 
 
11249 
 
11250 
  def __repr__(self):
11251 
    L = ['%s=%r' % (key, value)
11252 
      for key, value in self.__dict__.iteritems()]
11253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11254 
 
11255 
  def __eq__(self, other):
11256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11257 
 
11258 
  def __ne__(self, other):
11259 
    return not (self == other)
11260 
 
11261 
class getLatestArrivalsCatalogIds_result:
11262 
  """
11263 
  Attributes:
11264 
   - success
11265 
   - cex
11266 
  """
11267 
 
11268 
  thrift_spec = (
11269 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11270 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11271 
  )
11272 
 
11273 
  def __init__(self, success=None, cex=None,):
11274 
    self.success = success
11275 
    self.cex = cex
11276 
 
11277 
  def read(self, iprot):
11278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11280 
      return
11281 
    iprot.readStructBegin()
11282 
    while True:
11283 
      (fname, ftype, fid) = iprot.readFieldBegin()
11284 
      if ftype == TType.STOP:
11285 
        break
11286 
      if fid == 0:
11287 
        if ftype == TType.LIST:
11288 
          self.success = []
8590 kshitij.so 11289 
          (_etype147, _size144) = iprot.readListBegin()
11290 
          for _i148 in xrange(_size144):
11291 
            _elem149 = iprot.readI64();
11292 
            self.success.append(_elem149)
5944 mandeep.dh 11293 
          iprot.readListEnd()
11294 
        else:
11295 
          iprot.skip(ftype)
11296 
      elif fid == 1:
11297 
        if ftype == TType.STRUCT:
11298 
          self.cex = CatalogServiceException()
11299 
          self.cex.read(iprot)
11300 
        else:
11301 
          iprot.skip(ftype)
11302 
      else:
11303 
        iprot.skip(ftype)
11304 
      iprot.readFieldEnd()
11305 
    iprot.readStructEnd()
11306 
 
11307 
  def write(self, oprot):
11308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11310 
      return
11311 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11312 
    if self.success is not None:
11313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11314 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11315 
      for iter150 in self.success:
11316 
        oprot.writeI64(iter150)
5944 mandeep.dh 11317 
      oprot.writeListEnd()
11318 
      oprot.writeFieldEnd()
11319 
    if self.cex is not None:
11320 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11321 
      self.cex.write(oprot)
11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
11341 
class getLatestArrivalsCount_args:
11342 
 
11343 
  thrift_spec = (
11344 
  )
11345 
 
11346 
  def read(self, iprot):
11347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11349 
      return
11350 
    iprot.readStructBegin()
11351 
    while True:
11352 
      (fname, ftype, fid) = iprot.readFieldBegin()
11353 
      if ftype == TType.STOP:
11354 
        break
11355 
      else:
11356 
        iprot.skip(ftype)
11357 
      iprot.readFieldEnd()
11358 
    iprot.readStructEnd()
11359 
 
11360 
  def write(self, oprot):
11361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11363 
      return
11364 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11365 
    oprot.writeFieldStop()
11366 
    oprot.writeStructEnd()
11367 
 
11368 
  def validate(self):
11369 
    return
11370 
 
11371 
 
11372 
  def __repr__(self):
11373 
    L = ['%s=%r' % (key, value)
11374 
      for key, value in self.__dict__.iteritems()]
11375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11376 
 
11377 
  def __eq__(self, other):
11378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11379 
 
11380 
  def __ne__(self, other):
11381 
    return not (self == other)
11382 
 
11383 
class getLatestArrivalsCount_result:
11384 
  """
11385 
  Attributes:
11386 
   - success
11387 
   - cex
11388 
  """
11389 
 
11390 
  thrift_spec = (
11391 
    (0, TType.I64, 'success', None, None, ), # 0
11392 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11393 
  )
11394 
 
11395 
  def __init__(self, success=None, cex=None,):
11396 
    self.success = success
11397 
    self.cex = cex
11398 
 
11399 
  def read(self, iprot):
11400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11402 
      return
11403 
    iprot.readStructBegin()
11404 
    while True:
11405 
      (fname, ftype, fid) = iprot.readFieldBegin()
11406 
      if ftype == TType.STOP:
11407 
        break
11408 
      if fid == 0:
11409 
        if ftype == TType.I64:
11410 
          self.success = iprot.readI64();
11411 
        else:
11412 
          iprot.skip(ftype)
11413 
      elif fid == 1:
11414 
        if ftype == TType.STRUCT:
11415 
          self.cex = CatalogServiceException()
11416 
          self.cex.read(iprot)
11417 
        else:
11418 
          iprot.skip(ftype)
11419 
      else:
11420 
        iprot.skip(ftype)
11421 
      iprot.readFieldEnd()
11422 
    iprot.readStructEnd()
11423 
 
11424 
  def write(self, oprot):
11425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11427 
      return
11428 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11429 
    if self.success is not None:
11430 
      oprot.writeFieldBegin('success', TType.I64, 0)
11431 
      oprot.writeI64(self.success)
11432 
      oprot.writeFieldEnd()
11433 
    if self.cex is not None:
11434 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11435 
      self.cex.write(oprot)
11436 
      oprot.writeFieldEnd()
11437 
    oprot.writeFieldStop()
11438 
    oprot.writeStructEnd()
11439 
 
11440 
  def validate(self):
11441 
    return
11442 
 
11443 
 
11444 
  def __repr__(self):
11445 
    L = ['%s=%r' % (key, value)
11446 
      for key, value in self.__dict__.iteritems()]
11447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11448 
 
11449 
  def __eq__(self, other):
11450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11451 
 
11452 
  def __ne__(self, other):
11453 
    return not (self == other)
11454 
 
11455 
class generateNewEntityID_args:
11456 
 
11457 
  thrift_spec = (
11458 
  )
11459 
 
11460 
  def read(self, iprot):
11461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11463 
      return
11464 
    iprot.readStructBegin()
11465 
    while True:
11466 
      (fname, ftype, fid) = iprot.readFieldBegin()
11467 
      if ftype == TType.STOP:
11468 
        break
11469 
      else:
11470 
        iprot.skip(ftype)
11471 
      iprot.readFieldEnd()
11472 
    iprot.readStructEnd()
11473 
 
11474 
  def write(self, oprot):
11475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11477 
      return
11478 
    oprot.writeStructBegin('generateNewEntityID_args')
11479 
    oprot.writeFieldStop()
11480 
    oprot.writeStructEnd()
11481 
 
11482 
  def validate(self):
11483 
    return
11484 
 
11485 
 
11486 
  def __repr__(self):
11487 
    L = ['%s=%r' % (key, value)
11488 
      for key, value in self.__dict__.iteritems()]
11489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11490 
 
11491 
  def __eq__(self, other):
11492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11493 
 
11494 
  def __ne__(self, other):
11495 
    return not (self == other)
11496 
 
11497 
class generateNewEntityID_result:
11498 
  """
11499 
  Attributes:
11500 
   - success
11501 
  """
11502 
 
11503 
  thrift_spec = (
11504 
    (0, TType.I64, 'success', None, None, ), # 0
11505 
  )
11506 
 
11507 
  def __init__(self, success=None,):
11508 
    self.success = success
11509 
 
11510 
  def read(self, iprot):
11511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11513 
      return
11514 
    iprot.readStructBegin()
11515 
    while True:
11516 
      (fname, ftype, fid) = iprot.readFieldBegin()
11517 
      if ftype == TType.STOP:
11518 
        break
11519 
      if fid == 0:
11520 
        if ftype == TType.I64:
11521 
          self.success = iprot.readI64();
11522 
        else:
11523 
          iprot.skip(ftype)
11524 
      else:
11525 
        iprot.skip(ftype)
11526 
      iprot.readFieldEnd()
11527 
    iprot.readStructEnd()
11528 
 
11529 
  def write(self, oprot):
11530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11532 
      return
11533 
    oprot.writeStructBegin('generateNewEntityID_result')
11534 
    if self.success is not None:
11535 
      oprot.writeFieldBegin('success', TType.I64, 0)
11536 
      oprot.writeI64(self.success)
11537 
      oprot.writeFieldEnd()
11538 
    oprot.writeFieldStop()
11539 
    oprot.writeStructEnd()
11540 
 
11541 
  def validate(self):
11542 
    return
11543 
 
11544 
 
11545 
  def __repr__(self):
11546 
    L = ['%s=%r' % (key, value)
11547 
      for key, value in self.__dict__.iteritems()]
11548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11549 
 
11550 
  def __eq__(self, other):
11551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11552 
 
11553 
  def __ne__(self, other):
11554 
    return not (self == other)
11555 
 
11556 
class addCategory_args:
11557 
  """
11558 
  Attributes:
11559 
   - category
11560 
  """
11561 
 
11562 
  thrift_spec = (
11563 
    None, # 0
11564 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11565 
  )
11566 
 
11567 
  def __init__(self, category=None,):
11568 
    self.category = category
11569 
 
11570 
  def read(self, iprot):
11571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11573 
      return
11574 
    iprot.readStructBegin()
11575 
    while True:
11576 
      (fname, ftype, fid) = iprot.readFieldBegin()
11577 
      if ftype == TType.STOP:
11578 
        break
11579 
      if fid == 1:
11580 
        if ftype == TType.STRUCT:
11581 
          self.category = Category()
11582 
          self.category.read(iprot)
11583 
        else:
11584 
          iprot.skip(ftype)
11585 
      else:
11586 
        iprot.skip(ftype)
11587 
      iprot.readFieldEnd()
11588 
    iprot.readStructEnd()
11589 
 
11590 
  def write(self, oprot):
11591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11593 
      return
11594 
    oprot.writeStructBegin('addCategory_args')
11595 
    if self.category is not None:
11596 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11597 
      self.category.write(oprot)
11598 
      oprot.writeFieldEnd()
11599 
    oprot.writeFieldStop()
11600 
    oprot.writeStructEnd()
11601 
 
11602 
  def validate(self):
11603 
    return
11604 
 
11605 
 
11606 
  def __repr__(self):
11607 
    L = ['%s=%r' % (key, value)
11608 
      for key, value in self.__dict__.iteritems()]
11609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11610 
 
11611 
  def __eq__(self, other):
11612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11613 
 
11614 
  def __ne__(self, other):
11615 
    return not (self == other)
11616 
 
11617 
class addCategory_result:
11618 
  """
11619 
  Attributes:
11620 
   - success
11621 
  """
11622 
 
11623 
  thrift_spec = (
11624 
    (0, TType.BOOL, 'success', None, None, ), # 0
11625 
  )
11626 
 
11627 
  def __init__(self, success=None,):
11628 
    self.success = success
11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
11639 
      if fid == 0:
11640 
        if ftype == TType.BOOL:
11641 
          self.success = iprot.readBool();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('addCategory_result')
11654 
    if self.success is not None:
11655 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11656 
      oprot.writeBool(self.success)
11657 
      oprot.writeFieldEnd()
11658 
    oprot.writeFieldStop()
11659 
    oprot.writeStructEnd()
11660 
 
11661 
  def validate(self):
11662 
    return
11663 
 
11664 
 
11665 
  def __repr__(self):
11666 
    L = ['%s=%r' % (key, value)
11667 
      for key, value in self.__dict__.iteritems()]
11668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11669 
 
11670 
  def __eq__(self, other):
11671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11672 
 
11673 
  def __ne__(self, other):
11674 
    return not (self == other)
11675 
 
11676 
class getCategory_args:
11677 
  """
11678 
  Attributes:
11679 
   - id
11680 
  """
11681 
 
11682 
  thrift_spec = (
11683 
    None, # 0
11684 
    (1, TType.I64, 'id', None, None, ), # 1
11685 
  )
11686 
 
11687 
  def __init__(self, id=None,):
11688 
    self.id = id
11689 
 
11690 
  def read(self, iprot):
11691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11693 
      return
11694 
    iprot.readStructBegin()
11695 
    while True:
11696 
      (fname, ftype, fid) = iprot.readFieldBegin()
11697 
      if ftype == TType.STOP:
11698 
        break
11699 
      if fid == 1:
11700 
        if ftype == TType.I64:
11701 
          self.id = iprot.readI64();
11702 
        else:
11703 
          iprot.skip(ftype)
11704 
      else:
11705 
        iprot.skip(ftype)
11706 
      iprot.readFieldEnd()
11707 
    iprot.readStructEnd()
11708 
 
11709 
  def write(self, oprot):
11710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11712 
      return
11713 
    oprot.writeStructBegin('getCategory_args')
11714 
    if self.id is not None:
11715 
      oprot.writeFieldBegin('id', TType.I64, 1)
11716 
      oprot.writeI64(self.id)
11717 
      oprot.writeFieldEnd()
11718 
    oprot.writeFieldStop()
11719 
    oprot.writeStructEnd()
11720 
 
11721 
  def validate(self):
11722 
    return
11723 
 
11724 
 
11725 
  def __repr__(self):
11726 
    L = ['%s=%r' % (key, value)
11727 
      for key, value in self.__dict__.iteritems()]
11728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11729 
 
11730 
  def __eq__(self, other):
11731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11732 
 
11733 
  def __ne__(self, other):
11734 
    return not (self == other)
11735 
 
11736 
class getCategory_result:
11737 
  """
11738 
  Attributes:
11739 
   - success
11740 
  """
11741 
 
11742 
  thrift_spec = (
11743 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11744 
  )
11745 
 
11746 
  def __init__(self, success=None,):
11747 
    self.success = success
11748 
 
11749 
  def read(self, iprot):
11750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11752 
      return
11753 
    iprot.readStructBegin()
11754 
    while True:
11755 
      (fname, ftype, fid) = iprot.readFieldBegin()
11756 
      if ftype == TType.STOP:
11757 
        break
11758 
      if fid == 0:
11759 
        if ftype == TType.STRUCT:
11760 
          self.success = Category()
11761 
          self.success.read(iprot)
11762 
        else:
11763 
          iprot.skip(ftype)
11764 
      else:
11765 
        iprot.skip(ftype)
11766 
      iprot.readFieldEnd()
11767 
    iprot.readStructEnd()
11768 
 
11769 
  def write(self, oprot):
11770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11772 
      return
11773 
    oprot.writeStructBegin('getCategory_result')
11774 
    if self.success is not None:
11775 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11776 
      self.success.write(oprot)
11777 
      oprot.writeFieldEnd()
11778 
    oprot.writeFieldStop()
11779 
    oprot.writeStructEnd()
11780 
 
11781 
  def validate(self):
11782 
    return
11783 
 
11784 
 
11785 
  def __repr__(self):
11786 
    L = ['%s=%r' % (key, value)
11787 
      for key, value in self.__dict__.iteritems()]
11788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11789 
 
11790 
  def __eq__(self, other):
11791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11792 
 
11793 
  def __ne__(self, other):
11794 
    return not (self == other)
11795 
 
11796 
class getAllCategories_args:
11797 
 
11798 
  thrift_spec = (
11799 
  )
11800 
 
11801 
  def read(self, iprot):
11802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11804 
      return
11805 
    iprot.readStructBegin()
11806 
    while True:
11807 
      (fname, ftype, fid) = iprot.readFieldBegin()
11808 
      if ftype == TType.STOP:
11809 
        break
11810 
      else:
11811 
        iprot.skip(ftype)
11812 
      iprot.readFieldEnd()
11813 
    iprot.readStructEnd()
11814 
 
11815 
  def write(self, oprot):
11816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11818 
      return
11819 
    oprot.writeStructBegin('getAllCategories_args')
11820 
    oprot.writeFieldStop()
11821 
    oprot.writeStructEnd()
11822 
 
11823 
  def validate(self):
11824 
    return
11825 
 
11826 
 
11827 
  def __repr__(self):
11828 
    L = ['%s=%r' % (key, value)
11829 
      for key, value in self.__dict__.iteritems()]
11830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11831 
 
11832 
  def __eq__(self, other):
11833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11834 
 
11835 
  def __ne__(self, other):
11836 
    return not (self == other)
11837 
 
11838 
class getAllCategories_result:
11839 
  """
11840 
  Attributes:
11841 
   - success
11842 
  """
11843 
 
11844 
  thrift_spec = (
11845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11846 
  )
11847 
 
11848 
  def __init__(self, success=None,):
11849 
    self.success = success
11850 
 
11851 
  def read(self, iprot):
11852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11854 
      return
11855 
    iprot.readStructBegin()
11856 
    while True:
11857 
      (fname, ftype, fid) = iprot.readFieldBegin()
11858 
      if ftype == TType.STOP:
11859 
        break
11860 
      if fid == 0:
11861 
        if ftype == TType.LIST:
11862 
          self.success = []
8590 kshitij.so 11863 
          (_etype154, _size151) = iprot.readListBegin()
11864 
          for _i155 in xrange(_size151):
11865 
            _elem156 = Category()
11866 
            _elem156.read(iprot)
11867 
            self.success.append(_elem156)
5944 mandeep.dh 11868 
          iprot.readListEnd()
11869 
        else:
11870 
          iprot.skip(ftype)
11871 
      else:
11872 
        iprot.skip(ftype)
11873 
      iprot.readFieldEnd()
11874 
    iprot.readStructEnd()
11875 
 
11876 
  def write(self, oprot):
11877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11879 
      return
11880 
    oprot.writeStructBegin('getAllCategories_result')
11881 
    if self.success is not None:
11882 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11883 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11884 
      for iter157 in self.success:
11885 
        iter157.write(oprot)
5944 mandeep.dh 11886 
      oprot.writeListEnd()
11887 
      oprot.writeFieldEnd()
11888 
    oprot.writeFieldStop()
11889 
    oprot.writeStructEnd()
11890 
 
11891 
  def validate(self):
11892 
    return
11893 
 
11894 
 
11895 
  def __repr__(self):
11896 
    L = ['%s=%r' % (key, value)
11897 
      for key, value in self.__dict__.iteritems()]
11898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11899 
 
11900 
  def __eq__(self, other):
11901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11902 
 
11903 
  def __ne__(self, other):
11904 
    return not (self == other)
11905 
 
11906 
class getAllSimilarItems_args:
11907 
  """
11908 
  Attributes:
11909 
   - itemId
11910 
  """
11911 
 
11912 
  thrift_spec = (
11913 
    None, # 0
11914 
    (1, TType.I64, 'itemId', None, None, ), # 1
11915 
  )
11916 
 
11917 
  def __init__(self, itemId=None,):
11918 
    self.itemId = itemId
11919 
 
11920 
  def read(self, iprot):
11921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11923 
      return
11924 
    iprot.readStructBegin()
11925 
    while True:
11926 
      (fname, ftype, fid) = iprot.readFieldBegin()
11927 
      if ftype == TType.STOP:
11928 
        break
11929 
      if fid == 1:
11930 
        if ftype == TType.I64:
11931 
          self.itemId = iprot.readI64();
11932 
        else:
11933 
          iprot.skip(ftype)
11934 
      else:
11935 
        iprot.skip(ftype)
11936 
      iprot.readFieldEnd()
11937 
    iprot.readStructEnd()
11938 
 
11939 
  def write(self, oprot):
11940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11942 
      return
11943 
    oprot.writeStructBegin('getAllSimilarItems_args')
11944 
    if self.itemId is not None:
11945 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11946 
      oprot.writeI64(self.itemId)
11947 
      oprot.writeFieldEnd()
11948 
    oprot.writeFieldStop()
11949 
    oprot.writeStructEnd()
11950 
 
11951 
  def validate(self):
11952 
    return
11953 
 
11954 
 
11955 
  def __repr__(self):
11956 
    L = ['%s=%r' % (key, value)
11957 
      for key, value in self.__dict__.iteritems()]
11958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11959 
 
11960 
  def __eq__(self, other):
11961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11962 
 
11963 
  def __ne__(self, other):
11964 
    return not (self == other)
11965 
 
11966 
class getAllSimilarItems_result:
11967 
  """
11968 
  Attributes:
11969 
   - success
11970 
  """
11971 
 
11972 
  thrift_spec = (
11973 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11974 
  )
11975 
 
11976 
  def __init__(self, success=None,):
11977 
    self.success = success
11978 
 
11979 
  def read(self, iprot):
11980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11982 
      return
11983 
    iprot.readStructBegin()
11984 
    while True:
11985 
      (fname, ftype, fid) = iprot.readFieldBegin()
11986 
      if ftype == TType.STOP:
11987 
        break
11988 
      if fid == 0:
11989 
        if ftype == TType.LIST:
11990 
          self.success = []
8590 kshitij.so 11991 
          (_etype161, _size158) = iprot.readListBegin()
11992 
          for _i162 in xrange(_size158):
11993 
            _elem163 = Item()
11994 
            _elem163.read(iprot)
11995 
            self.success.append(_elem163)
5944 mandeep.dh 11996 
          iprot.readListEnd()
11997 
        else:
11998 
          iprot.skip(ftype)
11999 
      else:
12000 
        iprot.skip(ftype)
12001 
      iprot.readFieldEnd()
12002 
    iprot.readStructEnd()
12003 
 
12004 
  def write(self, oprot):
12005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12007 
      return
12008 
    oprot.writeStructBegin('getAllSimilarItems_result')
12009 
    if self.success is not None:
12010 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12011 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12012 
      for iter164 in self.success:
12013 
        iter164.write(oprot)
5944 mandeep.dh 12014 
      oprot.writeListEnd()
12015 
      oprot.writeFieldEnd()
12016 
    oprot.writeFieldStop()
12017 
    oprot.writeStructEnd()
12018 
 
12019 
  def validate(self):
12020 
    return
12021 
 
12022 
 
12023 
  def __repr__(self):
12024 
    L = ['%s=%r' % (key, value)
12025 
      for key, value in self.__dict__.iteritems()]
12026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12027 
 
12028 
  def __eq__(self, other):
12029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12030 
 
12031 
  def __ne__(self, other):
12032 
    return not (self == other)
12033 
 
12034 
class addSimilarItem_args:
12035 
  """
12036 
  Attributes:
12037 
   - itemId
12038 
   - catalogItemId
12039 
  """
12040 
 
12041 
  thrift_spec = (
12042 
    None, # 0
12043 
    (1, TType.I64, 'itemId', None, None, ), # 1
12044 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12045 
  )
12046 
 
12047 
  def __init__(self, itemId=None, catalogItemId=None,):
12048 
    self.itemId = itemId
12049 
    self.catalogItemId = catalogItemId
12050 
 
12051 
  def read(self, iprot):
12052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12054 
      return
12055 
    iprot.readStructBegin()
12056 
    while True:
12057 
      (fname, ftype, fid) = iprot.readFieldBegin()
12058 
      if ftype == TType.STOP:
12059 
        break
12060 
      if fid == 1:
12061 
        if ftype == TType.I64:
12062 
          self.itemId = iprot.readI64();
12063 
        else:
12064 
          iprot.skip(ftype)
12065 
      elif fid == 2:
12066 
        if ftype == TType.I64:
12067 
          self.catalogItemId = iprot.readI64();
12068 
        else:
12069 
          iprot.skip(ftype)
12070 
      else:
12071 
        iprot.skip(ftype)
12072 
      iprot.readFieldEnd()
12073 
    iprot.readStructEnd()
12074 
 
12075 
  def write(self, oprot):
12076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12078 
      return
12079 
    oprot.writeStructBegin('addSimilarItem_args')
12080 
    if self.itemId is not None:
12081 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12082 
      oprot.writeI64(self.itemId)
12083 
      oprot.writeFieldEnd()
12084 
    if self.catalogItemId is not None:
12085 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12086 
      oprot.writeI64(self.catalogItemId)
12087 
      oprot.writeFieldEnd()
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
12091 
  def validate(self):
12092 
    return
12093 
 
12094 
 
12095 
  def __repr__(self):
12096 
    L = ['%s=%r' % (key, value)
12097 
      for key, value in self.__dict__.iteritems()]
12098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12099 
 
12100 
  def __eq__(self, other):
12101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12102 
 
12103 
  def __ne__(self, other):
12104 
    return not (self == other)
12105 
 
12106 
class addSimilarItem_result:
12107 
  """
12108 
  Attributes:
12109 
   - success
12110 
   - cex
12111 
  """
12112 
 
12113 
  thrift_spec = (
12114 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12115 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12116 
  )
12117 
 
12118 
  def __init__(self, success=None, cex=None,):
12119 
    self.success = success
12120 
    self.cex = cex
12121 
 
12122 
  def read(self, iprot):
12123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12125 
      return
12126 
    iprot.readStructBegin()
12127 
    while True:
12128 
      (fname, ftype, fid) = iprot.readFieldBegin()
12129 
      if ftype == TType.STOP:
12130 
        break
12131 
      if fid == 0:
12132 
        if ftype == TType.STRUCT:
12133 
          self.success = Item()
12134 
          self.success.read(iprot)
12135 
        else:
12136 
          iprot.skip(ftype)
12137 
      elif fid == 1:
12138 
        if ftype == TType.STRUCT:
12139 
          self.cex = CatalogServiceException()
12140 
          self.cex.read(iprot)
12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
12152 
    oprot.writeStructBegin('addSimilarItem_result')
12153 
    if self.success is not None:
12154 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12155 
      self.success.write(oprot)
12156 
      oprot.writeFieldEnd()
12157 
    if self.cex is not None:
12158 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12159 
      self.cex.write(oprot)
12160 
      oprot.writeFieldEnd()
12161 
    oprot.writeFieldStop()
12162 
    oprot.writeStructEnd()
12163 
 
12164 
  def validate(self):
12165 
    return
12166 
 
12167 
 
12168 
  def __repr__(self):
12169 
    L = ['%s=%r' % (key, value)
12170 
      for key, value in self.__dict__.iteritems()]
12171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12172 
 
12173 
  def __eq__(self, other):
12174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12175 
 
12176 
  def __ne__(self, other):
12177 
    return not (self == other)
12178 
 
6512 kshitij.so 12179 
class addTag_args:
12180 
  """
12181 
  Attributes:
12182 
   - displayName
12183 
   - itemId
12184 
  """
12185 
 
12186 
  thrift_spec = (
12187 
    None, # 0
12188 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12189 
    (2, TType.I64, 'itemId', None, None, ), # 2
12190 
  )
12191 
 
12192 
  def __init__(self, displayName=None, itemId=None,):
12193 
    self.displayName = displayName
12194 
    self.itemId = itemId
12195 
 
12196 
  def read(self, iprot):
12197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12199 
      return
12200 
    iprot.readStructBegin()
12201 
    while True:
12202 
      (fname, ftype, fid) = iprot.readFieldBegin()
12203 
      if ftype == TType.STOP:
12204 
        break
12205 
      if fid == 1:
12206 
        if ftype == TType.STRING:
12207 
          self.displayName = iprot.readString();
12208 
        else:
12209 
          iprot.skip(ftype)
12210 
      elif fid == 2:
12211 
        if ftype == TType.I64:
12212 
          self.itemId = iprot.readI64();
12213 
        else:
12214 
          iprot.skip(ftype)
12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
12224 
    oprot.writeStructBegin('addTag_args')
12225 
    if self.displayName is not None:
12226 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12227 
      oprot.writeString(self.displayName)
12228 
      oprot.writeFieldEnd()
12229 
    if self.itemId is not None:
12230 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12231 
      oprot.writeI64(self.itemId)
12232 
      oprot.writeFieldEnd()
12233 
    oprot.writeFieldStop()
12234 
    oprot.writeStructEnd()
12235 
 
12236 
  def validate(self):
12237 
    return
12238 
 
12239 
 
12240 
  def __repr__(self):
12241 
    L = ['%s=%r' % (key, value)
12242 
      for key, value in self.__dict__.iteritems()]
12243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12244 
 
12245 
  def __eq__(self, other):
12246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12247 
 
12248 
  def __ne__(self, other):
12249 
    return not (self == other)
12250 
 
12251 
class addTag_result:
12252 
  """
12253 
  Attributes:
12254 
   - success
12255 
  """
12256 
 
12257 
  thrift_spec = (
12258 
    (0, TType.BOOL, 'success', None, None, ), # 0
12259 
  )
12260 
 
12261 
  def __init__(self, success=None,):
12262 
    self.success = success
12263 
 
12264 
  def read(self, iprot):
12265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12267 
      return
12268 
    iprot.readStructBegin()
12269 
    while True:
12270 
      (fname, ftype, fid) = iprot.readFieldBegin()
12271 
      if ftype == TType.STOP:
12272 
        break
12273 
      if fid == 0:
12274 
        if ftype == TType.BOOL:
12275 
          self.success = iprot.readBool();
12276 
        else:
12277 
          iprot.skip(ftype)
12278 
      else:
12279 
        iprot.skip(ftype)
12280 
      iprot.readFieldEnd()
12281 
    iprot.readStructEnd()
12282 
 
12283 
  def write(self, oprot):
12284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12286 
      return
12287 
    oprot.writeStructBegin('addTag_result')
12288 
    if self.success is not None:
12289 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12290 
      oprot.writeBool(self.success)
12291 
      oprot.writeFieldEnd()
12292 
    oprot.writeFieldStop()
12293 
    oprot.writeStructEnd()
12294 
 
12295 
  def validate(self):
12296 
    return
12297 
 
12298 
 
12299 
  def __repr__(self):
12300 
    L = ['%s=%r' % (key, value)
12301 
      for key, value in self.__dict__.iteritems()]
12302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12303 
 
12304 
  def __eq__(self, other):
12305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12306 
 
12307 
  def __ne__(self, other):
12308 
    return not (self == other)
12309 
 
12310 
class deleteEntityTag_args:
12311 
  """
12312 
  Attributes:
12313 
   - displayName
12314 
   - itemId
12315 
  """
12316 
 
12317 
  thrift_spec = (
12318 
    None, # 0
12319 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12320 
    (2, TType.I64, 'itemId', None, None, ), # 2
12321 
  )
12322 
 
12323 
  def __init__(self, displayName=None, itemId=None,):
12324 
    self.displayName = displayName
12325 
    self.itemId = itemId
12326 
 
12327 
  def read(self, iprot):
12328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12330 
      return
12331 
    iprot.readStructBegin()
12332 
    while True:
12333 
      (fname, ftype, fid) = iprot.readFieldBegin()
12334 
      if ftype == TType.STOP:
12335 
        break
12336 
      if fid == 1:
12337 
        if ftype == TType.STRING:
12338 
          self.displayName = iprot.readString();
12339 
        else:
12340 
          iprot.skip(ftype)
12341 
      elif fid == 2:
12342 
        if ftype == TType.I64:
12343 
          self.itemId = iprot.readI64();
12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      else:
12347 
        iprot.skip(ftype)
12348 
      iprot.readFieldEnd()
12349 
    iprot.readStructEnd()
12350 
 
12351 
  def write(self, oprot):
12352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12354 
      return
12355 
    oprot.writeStructBegin('deleteEntityTag_args')
12356 
    if self.displayName is not None:
12357 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12358 
      oprot.writeString(self.displayName)
12359 
      oprot.writeFieldEnd()
12360 
    if self.itemId is not None:
12361 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12362 
      oprot.writeI64(self.itemId)
12363 
      oprot.writeFieldEnd()
12364 
    oprot.writeFieldStop()
12365 
    oprot.writeStructEnd()
12366 
 
12367 
  def validate(self):
12368 
    return
12369 
 
12370 
 
12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
12382 
class deleteEntityTag_result:
12383 
  """
12384 
  Attributes:
12385 
   - success
12386 
  """
12387 
 
12388 
  thrift_spec = (
12389 
    (0, TType.BOOL, 'success', None, None, ), # 0
12390 
  )
12391 
 
12392 
  def __init__(self, success=None,):
12393 
    self.success = success
12394 
 
12395 
  def read(self, iprot):
12396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12398 
      return
12399 
    iprot.readStructBegin()
12400 
    while True:
12401 
      (fname, ftype, fid) = iprot.readFieldBegin()
12402 
      if ftype == TType.STOP:
12403 
        break
12404 
      if fid == 0:
12405 
        if ftype == TType.BOOL:
12406 
          self.success = iprot.readBool();
12407 
        else:
12408 
          iprot.skip(ftype)
12409 
      else:
12410 
        iprot.skip(ftype)
12411 
      iprot.readFieldEnd()
12412 
    iprot.readStructEnd()
12413 
 
12414 
  def write(self, oprot):
12415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12417 
      return
12418 
    oprot.writeStructBegin('deleteEntityTag_result')
12419 
    if self.success is not None:
12420 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12421 
      oprot.writeBool(self.success)
12422 
      oprot.writeFieldEnd()
12423 
    oprot.writeFieldStop()
12424 
    oprot.writeStructEnd()
12425 
 
12426 
  def validate(self):
12427 
    return
12428 
 
12429 
 
12430 
  def __repr__(self):
12431 
    L = ['%s=%r' % (key, value)
12432 
      for key, value in self.__dict__.iteritems()]
12433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12434 
 
12435 
  def __eq__(self, other):
12436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12437 
 
12438 
  def __ne__(self, other):
12439 
    return not (self == other)
12440 
 
12441 
class deleteTag_args:
12442 
  """
12443 
  Attributes:
12444 
   - displayName
12445 
  """
12446 
 
12447 
  thrift_spec = (
12448 
    None, # 0
12449 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12450 
  )
12451 
 
12452 
  def __init__(self, displayName=None,):
12453 
    self.displayName = displayName
12454 
 
12455 
  def read(self, iprot):
12456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12458 
      return
12459 
    iprot.readStructBegin()
12460 
    while True:
12461 
      (fname, ftype, fid) = iprot.readFieldBegin()
12462 
      if ftype == TType.STOP:
12463 
        break
12464 
      if fid == 1:
12465 
        if ftype == TType.STRING:
12466 
          self.displayName = iprot.readString();
12467 
        else:
12468 
          iprot.skip(ftype)
12469 
      else:
12470 
        iprot.skip(ftype)
12471 
      iprot.readFieldEnd()
12472 
    iprot.readStructEnd()
12473 
 
12474 
  def write(self, oprot):
12475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12477 
      return
12478 
    oprot.writeStructBegin('deleteTag_args')
12479 
    if self.displayName is not None:
12480 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12481 
      oprot.writeString(self.displayName)
12482 
      oprot.writeFieldEnd()
12483 
    oprot.writeFieldStop()
12484 
    oprot.writeStructEnd()
12485 
 
12486 
  def validate(self):
12487 
    return
12488 
 
12489 
 
12490 
  def __repr__(self):
12491 
    L = ['%s=%r' % (key, value)
12492 
      for key, value in self.__dict__.iteritems()]
12493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12494 
 
12495 
  def __eq__(self, other):
12496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12497 
 
12498 
  def __ne__(self, other):
12499 
    return not (self == other)
12500 
 
12501 
class deleteTag_result:
12502 
  """
12503 
  Attributes:
12504 
   - success
12505 
  """
12506 
 
12507 
  thrift_spec = (
12508 
    (0, TType.BOOL, 'success', None, None, ), # 0
12509 
  )
12510 
 
12511 
  def __init__(self, success=None,):
12512 
    self.success = success
12513 
 
12514 
  def read(self, iprot):
12515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12517 
      return
12518 
    iprot.readStructBegin()
12519 
    while True:
12520 
      (fname, ftype, fid) = iprot.readFieldBegin()
12521 
      if ftype == TType.STOP:
12522 
        break
12523 
      if fid == 0:
12524 
        if ftype == TType.BOOL:
12525 
          self.success = iprot.readBool();
12526 
        else:
12527 
          iprot.skip(ftype)
12528 
      else:
12529 
        iprot.skip(ftype)
12530 
      iprot.readFieldEnd()
12531 
    iprot.readStructEnd()
12532 
 
12533 
  def write(self, oprot):
12534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12536 
      return
12537 
    oprot.writeStructBegin('deleteTag_result')
12538 
    if self.success is not None:
12539 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12540 
      oprot.writeBool(self.success)
12541 
      oprot.writeFieldEnd()
12542 
    oprot.writeFieldStop()
12543 
    oprot.writeStructEnd()
12544 
 
12545 
  def validate(self):
12546 
    return
12547 
 
12548 
 
12549 
  def __repr__(self):
12550 
    L = ['%s=%r' % (key, value)
12551 
      for key, value in self.__dict__.iteritems()]
12552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12553 
 
12554 
  def __eq__(self, other):
12555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12556 
 
12557 
  def __ne__(self, other):
12558 
    return not (self == other)
12559 
 
12560 
class getAllTags_args:
12561 
 
12562 
  thrift_spec = (
12563 
  )
12564 
 
12565 
  def read(self, iprot):
12566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12568 
      return
12569 
    iprot.readStructBegin()
12570 
    while True:
12571 
      (fname, ftype, fid) = iprot.readFieldBegin()
12572 
      if ftype == TType.STOP:
12573 
        break
12574 
      else:
12575 
        iprot.skip(ftype)
12576 
      iprot.readFieldEnd()
12577 
    iprot.readStructEnd()
12578 
 
12579 
  def write(self, oprot):
12580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12582 
      return
12583 
    oprot.writeStructBegin('getAllTags_args')
12584 
    oprot.writeFieldStop()
12585 
    oprot.writeStructEnd()
12586 
 
12587 
  def validate(self):
12588 
    return
12589 
 
12590 
 
12591 
  def __repr__(self):
12592 
    L = ['%s=%r' % (key, value)
12593 
      for key, value in self.__dict__.iteritems()]
12594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12595 
 
12596 
  def __eq__(self, other):
12597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12598 
 
12599 
  def __ne__(self, other):
12600 
    return not (self == other)
12601 
 
12602 
class getAllTags_result:
12603 
  """
12604 
  Attributes:
12605 
   - success
12606 
  """
12607 
 
12608 
  thrift_spec = (
12609 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12610 
  )
12611 
 
12612 
  def __init__(self, success=None,):
12613 
    self.success = success
12614 
 
12615 
  def read(self, iprot):
12616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12618 
      return
12619 
    iprot.readStructBegin()
12620 
    while True:
12621 
      (fname, ftype, fid) = iprot.readFieldBegin()
12622 
      if ftype == TType.STOP:
12623 
        break
12624 
      if fid == 0:
12625 
        if ftype == TType.LIST:
12626 
          self.success = []
8590 kshitij.so 12627 
          (_etype168, _size165) = iprot.readListBegin()
12628 
          for _i169 in xrange(_size165):
12629 
            _elem170 = iprot.readString();
12630 
            self.success.append(_elem170)
6512 kshitij.so 12631 
          iprot.readListEnd()
12632 
        else:
12633 
          iprot.skip(ftype)
12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
12643 
    oprot.writeStructBegin('getAllTags_result')
12644 
    if self.success is not None:
12645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12646 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12647 
      for iter171 in self.success:
12648 
        oprot.writeString(iter171)
6512 kshitij.so 12649 
      oprot.writeListEnd()
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 
 
12669 
class getAllEntitiesByTagName_args:
12670 
  """
12671 
  Attributes:
12672 
   - displayName
12673 
  """
12674 
 
12675 
  thrift_spec = (
12676 
    None, # 0
12677 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12678 
  )
12679 
 
12680 
  def __init__(self, displayName=None,):
12681 
    self.displayName = displayName
12682 
 
12683 
  def read(self, iprot):
12684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12686 
      return
12687 
    iprot.readStructBegin()
12688 
    while True:
12689 
      (fname, ftype, fid) = iprot.readFieldBegin()
12690 
      if ftype == TType.STOP:
12691 
        break
12692 
      if fid == 1:
12693 
        if ftype == TType.STRING:
12694 
          self.displayName = iprot.readString();
12695 
        else:
12696 
          iprot.skip(ftype)
12697 
      else:
12698 
        iprot.skip(ftype)
12699 
      iprot.readFieldEnd()
12700 
    iprot.readStructEnd()
12701 
 
12702 
  def write(self, oprot):
12703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12705 
      return
12706 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12707 
    if self.displayName is not None:
12708 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12709 
      oprot.writeString(self.displayName)
12710 
      oprot.writeFieldEnd()
12711 
    oprot.writeFieldStop()
12712 
    oprot.writeStructEnd()
12713 
 
12714 
  def validate(self):
12715 
    return
12716 
 
12717 
 
12718 
  def __repr__(self):
12719 
    L = ['%s=%r' % (key, value)
12720 
      for key, value in self.__dict__.iteritems()]
12721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12722 
 
12723 
  def __eq__(self, other):
12724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12725 
 
12726 
  def __ne__(self, other):
12727 
    return not (self == other)
12728 
 
12729 
class getAllEntitiesByTagName_result:
12730 
  """
12731 
  Attributes:
12732 
   - success
12733 
  """
12734 
 
12735 
  thrift_spec = (
12736 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12737 
  )
12738 
 
12739 
  def __init__(self, success=None,):
12740 
    self.success = success
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 == 0:
12752 
        if ftype == TType.LIST:
12753 
          self.success = []
8590 kshitij.so 12754 
          (_etype175, _size172) = iprot.readListBegin()
12755 
          for _i176 in xrange(_size172):
12756 
            _elem177 = iprot.readI64();
12757 
            self.success.append(_elem177)
6512 kshitij.so 12758 
          iprot.readListEnd()
12759 
        else:
12760 
          iprot.skip(ftype)
12761 
      else:
12762 
        iprot.skip(ftype)
12763 
      iprot.readFieldEnd()
12764 
    iprot.readStructEnd()
12765 
 
12766 
  def write(self, oprot):
12767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12769 
      return
12770 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12771 
    if self.success is not None:
12772 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12773 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12774 
      for iter178 in self.success:
12775 
        oprot.writeI64(iter178)
6512 kshitij.so 12776 
      oprot.writeListEnd()
12777 
      oprot.writeFieldEnd()
12778 
    oprot.writeFieldStop()
12779 
    oprot.writeStructEnd()
12780 
 
12781 
  def validate(self):
12782 
    return
12783 
 
12784 
 
12785 
  def __repr__(self):
12786 
    L = ['%s=%r' % (key, value)
12787 
      for key, value in self.__dict__.iteritems()]
12788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12789 
 
12790 
  def __eq__(self, other):
12791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12792 
 
12793 
  def __ne__(self, other):
12794 
    return not (self == other)
12795 
 
6845 amit.gupta 12796 
class getAllEntityTags_args:
12797 
 
12798 
  thrift_spec = (
12799 
  )
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 
      else:
12811 
        iprot.skip(ftype)
12812 
      iprot.readFieldEnd()
12813 
    iprot.readStructEnd()
12814 
 
12815 
  def write(self, oprot):
12816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12818 
      return
12819 
    oprot.writeStructBegin('getAllEntityTags_args')
12820 
    oprot.writeFieldStop()
12821 
    oprot.writeStructEnd()
12822 
 
12823 
  def validate(self):
12824 
    return
12825 
 
12826 
 
12827 
  def __repr__(self):
12828 
    L = ['%s=%r' % (key, value)
12829 
      for key, value in self.__dict__.iteritems()]
12830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12831 
 
12832 
  def __eq__(self, other):
12833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12834 
 
12835 
  def __ne__(self, other):
12836 
    return not (self == other)
12837 
 
12838 
class getAllEntityTags_result:
12839 
  """
12840 
  Attributes:
12841 
   - success
12842 
  """
12843 
 
12844 
  thrift_spec = (
12845 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12846 
  )
12847 
 
12848 
  def __init__(self, success=None,):
12849 
    self.success = success
12850 
 
12851 
  def read(self, iprot):
12852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12854 
      return
12855 
    iprot.readStructBegin()
12856 
    while True:
12857 
      (fname, ftype, fid) = iprot.readFieldBegin()
12858 
      if ftype == TType.STOP:
12859 
        break
12860 
      if fid == 0:
12861 
        if ftype == TType.MAP:
12862 
          self.success = {}
8590 kshitij.so 12863 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12864 
          for _i183 in xrange(_size179):
12865 
            _key184 = iprot.readI64();
12866 
            _val185 = []
12867 
            (_etype189, _size186) = iprot.readListBegin()
12868 
            for _i190 in xrange(_size186):
12869 
              _elem191 = iprot.readString();
12870 
              _val185.append(_elem191)
6845 amit.gupta 12871 
            iprot.readListEnd()
8590 kshitij.so 12872 
            self.success[_key184] = _val185
6845 amit.gupta 12873 
          iprot.readMapEnd()
12874 
        else:
12875 
          iprot.skip(ftype)
12876 
      else:
12877 
        iprot.skip(ftype)
12878 
      iprot.readFieldEnd()
12879 
    iprot.readStructEnd()
12880 
 
12881 
  def write(self, oprot):
12882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12884 
      return
12885 
    oprot.writeStructBegin('getAllEntityTags_result')
12886 
    if self.success is not None:
12887 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12888 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12889 
      for kiter192,viter193 in self.success.items():
12890 
        oprot.writeI64(kiter192)
12891 
        oprot.writeListBegin(TType.STRING, len(viter193))
12892 
        for iter194 in viter193:
12893 
          oprot.writeString(iter194)
6845 amit.gupta 12894 
        oprot.writeListEnd()
12895 
      oprot.writeMapEnd()
12896 
      oprot.writeFieldEnd()
12897 
    oprot.writeFieldStop()
12898 
    oprot.writeStructEnd()
12899 
 
12900 
  def validate(self):
12901 
    return
12902 
 
12903 
 
12904 
  def __repr__(self):
12905 
    L = ['%s=%r' % (key, value)
12906 
      for key, value in self.__dict__.iteritems()]
12907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12908 
 
12909 
  def __eq__(self, other):
12910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12911 
 
12912 
  def __ne__(self, other):
12913 
    return not (self == other)
12914 
 
6850 kshitij.so 12915 
class addBanner_args:
12916 
  """
12917 
  Attributes:
8590 kshitij.so 12918 
   - bannerCongregate
6850 kshitij.so 12919 
  """
12920 
 
12921 
  thrift_spec = (
12922 
    None, # 0
8590 kshitij.so 12923 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12924 
  )
12925 
 
8590 kshitij.so 12926 
  def __init__(self, bannerCongregate=None,):
12927 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12928 
 
12929 
  def read(self, iprot):
12930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12932 
      return
12933 
    iprot.readStructBegin()
12934 
    while True:
12935 
      (fname, ftype, fid) = iprot.readFieldBegin()
12936 
      if ftype == TType.STOP:
12937 
        break
12938 
      if fid == 1:
8579 kshitij.so 12939 
        if ftype == TType.STRUCT:
8590 kshitij.so 12940 
          self.bannerCongregate = BannerCongregate()
12941 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12942 
        else:
12943 
          iprot.skip(ftype)
8579 kshitij.so 12944 
      else:
12945 
        iprot.skip(ftype)
12946 
      iprot.readFieldEnd()
12947 
    iprot.readStructEnd()
12948 
 
12949 
  def write(self, oprot):
12950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12952 
      return
12953 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12954 
    if self.bannerCongregate is not None:
12955 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12956 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12957 
      oprot.writeFieldEnd()
12958 
    oprot.writeFieldStop()
12959 
    oprot.writeStructEnd()
12960 
 
12961 
  def validate(self):
12962 
    return
12963 
 
12964 
 
12965 
  def __repr__(self):
12966 
    L = ['%s=%r' % (key, value)
12967 
      for key, value in self.__dict__.iteritems()]
12968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12969 
 
12970 
  def __eq__(self, other):
12971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12972 
 
12973 
  def __ne__(self, other):
12974 
    return not (self == other)
12975 
 
12976 
class addBanner_result:
12977 
 
12978 
  thrift_spec = (
12979 
  )
12980 
 
12981 
  def read(self, iprot):
12982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12984 
      return
12985 
    iprot.readStructBegin()
12986 
    while True:
12987 
      (fname, ftype, fid) = iprot.readFieldBegin()
12988 
      if ftype == TType.STOP:
12989 
        break
12990 
      else:
12991 
        iprot.skip(ftype)
12992 
      iprot.readFieldEnd()
12993 
    iprot.readStructEnd()
12994 
 
12995 
  def write(self, oprot):
12996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12998 
      return
12999 
    oprot.writeStructBegin('addBanner_result')
13000 
    oprot.writeFieldStop()
13001 
    oprot.writeStructEnd()
13002 
 
13003 
  def validate(self):
13004 
    return
13005 
 
13006 
 
13007 
  def __repr__(self):
13008 
    L = ['%s=%r' % (key, value)
13009 
      for key, value in self.__dict__.iteritems()]
13010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13011 
 
13012 
  def __eq__(self, other):
13013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13014 
 
13015 
  def __ne__(self, other):
13016 
    return not (self == other)
13017 
 
13018 
class updateBanner_args:
13019 
  """
13020 
  Attributes:
13021 
   - banner
13022 
  """
13023 
 
13024 
  thrift_spec = (
13025 
    None, # 0
13026 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13027 
  )
13028 
 
13029 
  def __init__(self, banner=None,):
13030 
    self.banner = banner
13031 
 
13032 
  def read(self, iprot):
13033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13035 
      return
13036 
    iprot.readStructBegin()
13037 
    while True:
13038 
      (fname, ftype, fid) = iprot.readFieldBegin()
13039 
      if ftype == TType.STOP:
13040 
        break
13041 
      if fid == 1:
13042 
        if ftype == TType.STRUCT:
13043 
          self.banner = Banner()
13044 
          self.banner.read(iprot)
6850 kshitij.so 13045 
        else:
13046 
          iprot.skip(ftype)
13047 
      else:
13048 
        iprot.skip(ftype)
13049 
      iprot.readFieldEnd()
13050 
    iprot.readStructEnd()
13051 
 
13052 
  def write(self, oprot):
13053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13055 
      return
8579 kshitij.so 13056 
    oprot.writeStructBegin('updateBanner_args')
13057 
    if self.banner is not None:
13058 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13059 
      self.banner.write(oprot)
6850 kshitij.so 13060 
      oprot.writeFieldEnd()
13061 
    oprot.writeFieldStop()
13062 
    oprot.writeStructEnd()
13063 
 
13064 
  def validate(self):
13065 
    return
13066 
 
13067 
 
13068 
  def __repr__(self):
13069 
    L = ['%s=%r' % (key, value)
13070 
      for key, value in self.__dict__.iteritems()]
13071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13072 
 
13073 
  def __eq__(self, other):
13074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13075 
 
13076 
  def __ne__(self, other):
13077 
    return not (self == other)
13078 
 
8579 kshitij.so 13079 
class updateBanner_result:
6850 kshitij.so 13080 
  """
13081 
  Attributes:
13082 
   - success
13083 
  """
13084 
 
13085 
  thrift_spec = (
13086 
    (0, TType.BOOL, 'success', None, None, ), # 0
13087 
  )
13088 
 
13089 
  def __init__(self, success=None,):
13090 
    self.success = success
13091 
 
13092 
  def read(self, iprot):
13093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13095 
      return
13096 
    iprot.readStructBegin()
13097 
    while True:
13098 
      (fname, ftype, fid) = iprot.readFieldBegin()
13099 
      if ftype == TType.STOP:
13100 
        break
13101 
      if fid == 0:
13102 
        if ftype == TType.BOOL:
13103 
          self.success = iprot.readBool();
13104 
        else:
13105 
          iprot.skip(ftype)
13106 
      else:
13107 
        iprot.skip(ftype)
13108 
      iprot.readFieldEnd()
13109 
    iprot.readStructEnd()
13110 
 
13111 
  def write(self, oprot):
13112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13114 
      return
8579 kshitij.so 13115 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13116 
    if self.success is not None:
13117 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13118 
      oprot.writeBool(self.success)
13119 
      oprot.writeFieldEnd()
13120 
    oprot.writeFieldStop()
13121 
    oprot.writeStructEnd()
13122 
 
13123 
  def validate(self):
13124 
    return
13125 
 
13126 
 
13127 
  def __repr__(self):
13128 
    L = ['%s=%r' % (key, value)
13129 
      for key, value in self.__dict__.iteritems()]
13130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13131 
 
13132 
  def __eq__(self, other):
13133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13134 
 
13135 
  def __ne__(self, other):
13136 
    return not (self == other)
13137 
 
13138 
class getAllBanners_args:
13139 
 
13140 
  thrift_spec = (
13141 
  )
13142 
 
13143 
  def read(self, iprot):
13144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13146 
      return
13147 
    iprot.readStructBegin()
13148 
    while True:
13149 
      (fname, ftype, fid) = iprot.readFieldBegin()
13150 
      if ftype == TType.STOP:
13151 
        break
13152 
      else:
13153 
        iprot.skip(ftype)
13154 
      iprot.readFieldEnd()
13155 
    iprot.readStructEnd()
13156 
 
13157 
  def write(self, oprot):
13158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13160 
      return
13161 
    oprot.writeStructBegin('getAllBanners_args')
13162 
    oprot.writeFieldStop()
13163 
    oprot.writeStructEnd()
13164 
 
13165 
  def validate(self):
13166 
    return
13167 
 
13168 
 
13169 
  def __repr__(self):
13170 
    L = ['%s=%r' % (key, value)
13171 
      for key, value in self.__dict__.iteritems()]
13172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13173 
 
13174 
  def __eq__(self, other):
13175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13176 
 
13177 
  def __ne__(self, other):
13178 
    return not (self == other)
13179 
 
13180 
class getAllBanners_result:
13181 
  """
13182 
  Attributes:
13183 
   - success
13184 
  """
13185 
 
13186 
  thrift_spec = (
8579 kshitij.so 13187 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13188 
  )
13189 
 
13190 
  def __init__(self, success=None,):
13191 
    self.success = success
13192 
 
13193 
  def read(self, iprot):
13194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13196 
      return
13197 
    iprot.readStructBegin()
13198 
    while True:
13199 
      (fname, ftype, fid) = iprot.readFieldBegin()
13200 
      if ftype == TType.STOP:
13201 
        break
13202 
      if fid == 0:
13203 
        if ftype == TType.LIST:
13204 
          self.success = []
8590 kshitij.so 13205 
          (_etype198, _size195) = iprot.readListBegin()
13206 
          for _i199 in xrange(_size195):
13207 
            _elem200 = Banner()
13208 
            _elem200.read(iprot)
13209 
            self.success.append(_elem200)
6850 kshitij.so 13210 
          iprot.readListEnd()
13211 
        else:
13212 
          iprot.skip(ftype)
13213 
      else:
13214 
        iprot.skip(ftype)
13215 
      iprot.readFieldEnd()
13216 
    iprot.readStructEnd()
13217 
 
13218 
  def write(self, oprot):
13219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13221 
      return
13222 
    oprot.writeStructBegin('getAllBanners_result')
13223 
    if self.success is not None:
13224 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13225 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13226 
      for iter201 in self.success:
13227 
        iter201.write(oprot)
6850 kshitij.so 13228 
      oprot.writeListEnd()
13229 
      oprot.writeFieldEnd()
13230 
    oprot.writeFieldStop()
13231 
    oprot.writeStructEnd()
13232 
 
13233 
  def validate(self):
13234 
    return
13235 
 
13236 
 
13237 
  def __repr__(self):
13238 
    L = ['%s=%r' % (key, value)
13239 
      for key, value in self.__dict__.iteritems()]
13240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13241 
 
13242 
  def __eq__(self, other):
13243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13244 
 
13245 
  def __ne__(self, other):
13246 
    return not (self == other)
13247 
 
13248 
class deleteBanner_args:
13249 
  """
13250 
  Attributes:
13251 
   - bannerName
9155 kshitij.so 13252 
   - bannerType
6850 kshitij.so 13253 
  """
13254 
 
13255 
  thrift_spec = (
13256 
    None, # 0
13257 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13258 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13259 
  )
13260 
 
9155 kshitij.so 13261 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13262 
    self.bannerName = bannerName
9155 kshitij.so 13263 
    self.bannerType = bannerType
6850 kshitij.so 13264 
 
13265 
  def read(self, iprot):
13266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13268 
      return
13269 
    iprot.readStructBegin()
13270 
    while True:
13271 
      (fname, ftype, fid) = iprot.readFieldBegin()
13272 
      if ftype == TType.STOP:
13273 
        break
13274 
      if fid == 1:
13275 
        if ftype == TType.STRING:
13276 
          self.bannerName = iprot.readString();
13277 
        else:
13278 
          iprot.skip(ftype)
9155 kshitij.so 13279 
      elif fid == 2:
13280 
        if ftype == TType.I32:
13281 
          self.bannerType = iprot.readI32();
13282 
        else:
13283 
          iprot.skip(ftype)
6850 kshitij.so 13284 
      else:
13285 
        iprot.skip(ftype)
13286 
      iprot.readFieldEnd()
13287 
    iprot.readStructEnd()
13288 
 
13289 
  def write(self, oprot):
13290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13292 
      return
13293 
    oprot.writeStructBegin('deleteBanner_args')
13294 
    if self.bannerName is not None:
13295 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13296 
      oprot.writeString(self.bannerName)
13297 
      oprot.writeFieldEnd()
9155 kshitij.so 13298 
    if self.bannerType is not None:
13299 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13300 
      oprot.writeI32(self.bannerType)
13301 
      oprot.writeFieldEnd()
6850 kshitij.so 13302 
    oprot.writeFieldStop()
13303 
    oprot.writeStructEnd()
13304 
 
13305 
  def validate(self):
13306 
    return
13307 
 
13308 
 
13309 
  def __repr__(self):
13310 
    L = ['%s=%r' % (key, value)
13311 
      for key, value in self.__dict__.iteritems()]
13312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13313 
 
13314 
  def __eq__(self, other):
13315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13316 
 
13317 
  def __ne__(self, other):
13318 
    return not (self == other)
13319 
 
13320 
class deleteBanner_result:
13321 
  """
13322 
  Attributes:
13323 
   - success
13324 
  """
13325 
 
13326 
  thrift_spec = (
13327 
    (0, TType.BOOL, 'success', None, None, ), # 0
13328 
  )
13329 
 
13330 
  def __init__(self, success=None,):
13331 
    self.success = success
13332 
 
13333 
  def read(self, iprot):
13334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13336 
      return
13337 
    iprot.readStructBegin()
13338 
    while True:
13339 
      (fname, ftype, fid) = iprot.readFieldBegin()
13340 
      if ftype == TType.STOP:
13341 
        break
13342 
      if fid == 0:
13343 
        if ftype == TType.BOOL:
13344 
          self.success = iprot.readBool();
13345 
        else:
13346 
          iprot.skip(ftype)
13347 
      else:
13348 
        iprot.skip(ftype)
13349 
      iprot.readFieldEnd()
13350 
    iprot.readStructEnd()
13351 
 
13352 
  def write(self, oprot):
13353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13355 
      return
13356 
    oprot.writeStructBegin('deleteBanner_result')
13357 
    if self.success is not None:
13358 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13359 
      oprot.writeBool(self.success)
13360 
      oprot.writeFieldEnd()
13361 
    oprot.writeFieldStop()
13362 
    oprot.writeStructEnd()
13363 
 
13364 
  def validate(self):
13365 
    return
13366 
 
13367 
 
13368 
  def __repr__(self):
13369 
    L = ['%s=%r' % (key, value)
13370 
      for key, value in self.__dict__.iteritems()]
13371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13372 
 
13373 
  def __eq__(self, other):
13374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13375 
 
13376 
  def __ne__(self, other):
13377 
    return not (self == other)
13378 
 
13379 
class getBannerDetails_args:
13380 
  """
13381 
  Attributes:
13382 
   - bannerName
9155 kshitij.so 13383 
   - bannerType
6850 kshitij.so 13384 
  """
13385 
 
13386 
  thrift_spec = (
13387 
    None, # 0
13388 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13389 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13390 
  )
13391 
 
9155 kshitij.so 13392 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13393 
    self.bannerName = bannerName
9155 kshitij.so 13394 
    self.bannerType = bannerType
6850 kshitij.so 13395 
 
13396 
  def read(self, iprot):
13397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13399 
      return
13400 
    iprot.readStructBegin()
13401 
    while True:
13402 
      (fname, ftype, fid) = iprot.readFieldBegin()
13403 
      if ftype == TType.STOP:
13404 
        break
13405 
      if fid == 1:
13406 
        if ftype == TType.STRING:
13407 
          self.bannerName = iprot.readString();
13408 
        else:
13409 
          iprot.skip(ftype)
9155 kshitij.so 13410 
      elif fid == 2:
13411 
        if ftype == TType.I32:
13412 
          self.bannerType = iprot.readI32();
13413 
        else:
13414 
          iprot.skip(ftype)
6850 kshitij.so 13415 
      else:
13416 
        iprot.skip(ftype)
13417 
      iprot.readFieldEnd()
13418 
    iprot.readStructEnd()
13419 
 
13420 
  def write(self, oprot):
13421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13423 
      return
13424 
    oprot.writeStructBegin('getBannerDetails_args')
13425 
    if self.bannerName is not None:
13426 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13427 
      oprot.writeString(self.bannerName)
13428 
      oprot.writeFieldEnd()
9155 kshitij.so 13429 
    if self.bannerType is not None:
13430 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13431 
      oprot.writeI32(self.bannerType)
13432 
      oprot.writeFieldEnd()
6850 kshitij.so 13433 
    oprot.writeFieldStop()
13434 
    oprot.writeStructEnd()
13435 
 
13436 
  def validate(self):
13437 
    return
13438 
 
13439 
 
13440 
  def __repr__(self):
13441 
    L = ['%s=%r' % (key, value)
13442 
      for key, value in self.__dict__.iteritems()]
13443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13444 
 
13445 
  def __eq__(self, other):
13446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13447 
 
13448 
  def __ne__(self, other):
13449 
    return not (self == other)
13450 
 
13451 
class getBannerDetails_result:
13452 
  """
13453 
  Attributes:
13454 
   - success
13455 
  """
13456 
 
13457 
  thrift_spec = (
13458 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13459 
  )
13460 
 
13461 
  def __init__(self, success=None,):
13462 
    self.success = success
13463 
 
13464 
  def read(self, iprot):
13465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13467 
      return
13468 
    iprot.readStructBegin()
13469 
    while True:
13470 
      (fname, ftype, fid) = iprot.readFieldBegin()
13471 
      if ftype == TType.STOP:
13472 
        break
13473 
      if fid == 0:
13474 
        if ftype == TType.STRUCT:
13475 
          self.success = Banner()
13476 
          self.success.read(iprot)
13477 
        else:
13478 
          iprot.skip(ftype)
13479 
      else:
13480 
        iprot.skip(ftype)
13481 
      iprot.readFieldEnd()
13482 
    iprot.readStructEnd()
13483 
 
13484 
  def write(self, oprot):
13485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13487 
      return
13488 
    oprot.writeStructBegin('getBannerDetails_result')
13489 
    if self.success is not None:
13490 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13491 
      self.success.write(oprot)
13492 
      oprot.writeFieldEnd()
13493 
    oprot.writeFieldStop()
13494 
    oprot.writeStructEnd()
13495 
 
13496 
  def validate(self):
13497 
    return
13498 
 
13499 
 
13500 
  def __repr__(self):
13501 
    L = ['%s=%r' % (key, value)
13502 
      for key, value in self.__dict__.iteritems()]
13503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13504 
 
13505 
  def __eq__(self, other):
13506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13507 
 
13508 
  def __ne__(self, other):
13509 
    return not (self == other)
13510 
 
13511 
class getActiveBanners_args:
13512 
 
13513 
  thrift_spec = (
13514 
  )
13515 
 
13516 
  def read(self, iprot):
13517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13519 
      return
13520 
    iprot.readStructBegin()
13521 
    while True:
13522 
      (fname, ftype, fid) = iprot.readFieldBegin()
13523 
      if ftype == TType.STOP:
13524 
        break
13525 
      else:
13526 
        iprot.skip(ftype)
13527 
      iprot.readFieldEnd()
13528 
    iprot.readStructEnd()
13529 
 
13530 
  def write(self, oprot):
13531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13533 
      return
13534 
    oprot.writeStructBegin('getActiveBanners_args')
13535 
    oprot.writeFieldStop()
13536 
    oprot.writeStructEnd()
13537 
 
13538 
  def validate(self):
13539 
    return
13540 
 
13541 
 
13542 
  def __repr__(self):
13543 
    L = ['%s=%r' % (key, value)
13544 
      for key, value in self.__dict__.iteritems()]
13545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13546 
 
13547 
  def __eq__(self, other):
13548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13549 
 
13550 
  def __ne__(self, other):
13551 
    return not (self == other)
13552 
 
13553 
class getActiveBanners_result:
13554 
  """
13555 
  Attributes:
13556 
   - success
13557 
  """
13558 
 
13559 
  thrift_spec = (
8579 kshitij.so 13560 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13561 
  )
13562 
 
13563 
  def __init__(self, success=None,):
13564 
    self.success = success
13565 
 
13566 
  def read(self, iprot):
13567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13569 
      return
13570 
    iprot.readStructBegin()
13571 
    while True:
13572 
      (fname, ftype, fid) = iprot.readFieldBegin()
13573 
      if ftype == TType.STOP:
13574 
        break
13575 
      if fid == 0:
8579 kshitij.so 13576 
        if ftype == TType.MAP:
13577 
          self.success = {}
8590 kshitij.so 13578 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13579 
          for _i206 in xrange(_size202):
13580 
            _key207 = iprot.readString();
13581 
            _val208 = []
13582 
            (_etype212, _size209) = iprot.readListBegin()
13583 
            for _i213 in xrange(_size209):
13584 
              _elem214 = Banner()
13585 
              _elem214.read(iprot)
13586 
              _val208.append(_elem214)
8579 kshitij.so 13587 
            iprot.readListEnd()
8590 kshitij.so 13588 
            self.success[_key207] = _val208
8579 kshitij.so 13589 
          iprot.readMapEnd()
6850 kshitij.so 13590 
        else:
13591 
          iprot.skip(ftype)
13592 
      else:
13593 
        iprot.skip(ftype)
13594 
      iprot.readFieldEnd()
13595 
    iprot.readStructEnd()
13596 
 
13597 
  def write(self, oprot):
13598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13600 
      return
13601 
    oprot.writeStructBegin('getActiveBanners_result')
13602 
    if self.success is not None:
8579 kshitij.so 13603 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13604 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13605 
      for kiter215,viter216 in self.success.items():
13606 
        oprot.writeString(kiter215)
13607 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13608 
        for iter217 in viter216:
13609 
          iter217.write(oprot)
8579 kshitij.so 13610 
        oprot.writeListEnd()
13611 
      oprot.writeMapEnd()
6850 kshitij.so 13612 
      oprot.writeFieldEnd()
13613 
    oprot.writeFieldStop()
13614 
    oprot.writeStructEnd()
13615 
 
13616 
  def validate(self):
13617 
    return
13618 
 
13619 
 
13620 
  def __repr__(self):
13621 
    L = ['%s=%r' % (key, value)
13622 
      for key, value in self.__dict__.iteritems()]
13623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13624 
 
13625 
  def __eq__(self, other):
13626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13627 
 
13628 
  def __ne__(self, other):
13629 
    return not (self == other)
13630 
 
6849 kshitij.so 13631 
class addBannerMap_args:
13632 
  """
13633 
  Attributes:
8579 kshitij.so 13634 
   - bannerMaps
6849 kshitij.so 13635 
  """
13636 
 
13637 
  thrift_spec = (
13638 
    None, # 0
8579 kshitij.so 13639 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13640 
  )
13641 
 
8579 kshitij.so 13642 
  def __init__(self, bannerMaps=None,):
13643 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13644 
 
13645 
  def read(self, iprot):
13646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13648 
      return
13649 
    iprot.readStructBegin()
13650 
    while True:
13651 
      (fname, ftype, fid) = iprot.readFieldBegin()
13652 
      if ftype == TType.STOP:
13653 
        break
13654 
      if fid == 1:
8579 kshitij.so 13655 
        if ftype == TType.LIST:
13656 
          self.bannerMaps = []
8590 kshitij.so 13657 
          (_etype221, _size218) = iprot.readListBegin()
13658 
          for _i222 in xrange(_size218):
13659 
            _elem223 = BannerMap()
13660 
            _elem223.read(iprot)
13661 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13662 
          iprot.readListEnd()
6849 kshitij.so 13663 
        else:
13664 
          iprot.skip(ftype)
8579 kshitij.so 13665 
      else:
13666 
        iprot.skip(ftype)
13667 
      iprot.readFieldEnd()
13668 
    iprot.readStructEnd()
13669 
 
13670 
  def write(self, oprot):
13671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13673 
      return
13674 
    oprot.writeStructBegin('addBannerMap_args')
13675 
    if self.bannerMaps is not None:
13676 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13677 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13678 
      for iter224 in self.bannerMaps:
13679 
        iter224.write(oprot)
8579 kshitij.so 13680 
      oprot.writeListEnd()
13681 
      oprot.writeFieldEnd()
13682 
    oprot.writeFieldStop()
13683 
    oprot.writeStructEnd()
13684 
 
13685 
  def validate(self):
13686 
    return
13687 
 
13688 
 
13689 
  def __repr__(self):
13690 
    L = ['%s=%r' % (key, value)
13691 
      for key, value in self.__dict__.iteritems()]
13692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13693 
 
13694 
  def __eq__(self, other):
13695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13696 
 
13697 
  def __ne__(self, other):
13698 
    return not (self == other)
13699 
 
13700 
class addBannerMap_result:
13701 
  """
13702 
  Attributes:
13703 
   - success
13704 
  """
13705 
 
13706 
  thrift_spec = (
13707 
    (0, TType.BOOL, 'success', None, None, ), # 0
13708 
  )
13709 
 
13710 
  def __init__(self, success=None,):
13711 
    self.success = success
13712 
 
13713 
  def read(self, iprot):
13714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13716 
      return
13717 
    iprot.readStructBegin()
13718 
    while True:
13719 
      (fname, ftype, fid) = iprot.readFieldBegin()
13720 
      if ftype == TType.STOP:
13721 
        break
13722 
      if fid == 0:
13723 
        if ftype == TType.BOOL:
13724 
          self.success = iprot.readBool();
6849 kshitij.so 13725 
        else:
13726 
          iprot.skip(ftype)
8579 kshitij.so 13727 
      else:
13728 
        iprot.skip(ftype)
13729 
      iprot.readFieldEnd()
13730 
    iprot.readStructEnd()
13731 
 
13732 
  def write(self, oprot):
13733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13735 
      return
13736 
    oprot.writeStructBegin('addBannerMap_result')
13737 
    if self.success is not None:
13738 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13739 
      oprot.writeBool(self.success)
13740 
      oprot.writeFieldEnd()
13741 
    oprot.writeFieldStop()
13742 
    oprot.writeStructEnd()
13743 
 
13744 
  def validate(self):
13745 
    return
13746 
 
13747 
 
13748 
  def __repr__(self):
13749 
    L = ['%s=%r' % (key, value)
13750 
      for key, value in self.__dict__.iteritems()]
13751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13752 
 
13753 
  def __eq__(self, other):
13754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13755 
 
13756 
  def __ne__(self, other):
13757 
    return not (self == other)
13758 
 
13759 
class updateBannerMap_args:
13760 
  """
13761 
  Attributes:
13762 
   - bannerMap
13763 
  """
13764 
 
13765 
  thrift_spec = (
13766 
    None, # 0
13767 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13768 
  )
13769 
 
13770 
  def __init__(self, bannerMap=None,):
13771 
    self.bannerMap = bannerMap
13772 
 
13773 
  def read(self, iprot):
13774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13776 
      return
13777 
    iprot.readStructBegin()
13778 
    while True:
13779 
      (fname, ftype, fid) = iprot.readFieldBegin()
13780 
      if ftype == TType.STOP:
13781 
        break
13782 
      if fid == 1:
13783 
        if ftype == TType.STRUCT:
13784 
          self.bannerMap = BannerMap()
13785 
          self.bannerMap.read(iprot)
6849 kshitij.so 13786 
        else:
13787 
          iprot.skip(ftype)
13788 
      else:
13789 
        iprot.skip(ftype)
13790 
      iprot.readFieldEnd()
13791 
    iprot.readStructEnd()
13792 
 
13793 
  def write(self, oprot):
13794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13796 
      return
8579 kshitij.so 13797 
    oprot.writeStructBegin('updateBannerMap_args')
13798 
    if self.bannerMap is not None:
13799 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13800 
      self.bannerMap.write(oprot)
6849 kshitij.so 13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
13809 
  def __repr__(self):
13810 
    L = ['%s=%r' % (key, value)
13811 
      for key, value in self.__dict__.iteritems()]
13812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13813 
 
13814 
  def __eq__(self, other):
13815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13816 
 
13817 
  def __ne__(self, other):
13818 
    return not (self == other)
13819 
 
8579 kshitij.so 13820 
class updateBannerMap_result:
6849 kshitij.so 13821 
  """
13822 
  Attributes:
13823 
   - success
13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    (0, TType.BOOL, 'success', None, None, ), # 0
13828 
  )
13829 
 
13830 
  def __init__(self, success=None,):
13831 
    self.success = success
13832 
 
13833 
  def read(self, iprot):
13834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13836 
      return
13837 
    iprot.readStructBegin()
13838 
    while True:
13839 
      (fname, ftype, fid) = iprot.readFieldBegin()
13840 
      if ftype == TType.STOP:
13841 
        break
13842 
      if fid == 0:
13843 
        if ftype == TType.BOOL:
13844 
          self.success = iprot.readBool();
13845 
        else:
13846 
          iprot.skip(ftype)
13847 
      else:
13848 
        iprot.skip(ftype)
13849 
      iprot.readFieldEnd()
13850 
    iprot.readStructEnd()
13851 
 
13852 
  def write(self, oprot):
13853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13855 
      return
8579 kshitij.so 13856 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13857 
    if self.success is not None:
13858 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13859 
      oprot.writeBool(self.success)
13860 
      oprot.writeFieldEnd()
13861 
    oprot.writeFieldStop()
13862 
    oprot.writeStructEnd()
13863 
 
13864 
  def validate(self):
13865 
    return
13866 
 
13867 
 
13868 
  def __repr__(self):
13869 
    L = ['%s=%r' % (key, value)
13870 
      for key, value in self.__dict__.iteritems()]
13871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13872 
 
13873 
  def __eq__(self, other):
13874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13875 
 
13876 
  def __ne__(self, other):
13877 
    return not (self == other)
13878 
 
13879 
class deleteBannerMap_args:
13880 
  """
13881 
  Attributes:
13882 
   - bannerName
13883 
  """
13884 
 
13885 
  thrift_spec = (
13886 
    None, # 0
13887 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13888 
  )
13889 
 
13890 
  def __init__(self, bannerName=None,):
13891 
    self.bannerName = bannerName
13892 
 
13893 
  def read(self, iprot):
13894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13896 
      return
13897 
    iprot.readStructBegin()
13898 
    while True:
13899 
      (fname, ftype, fid) = iprot.readFieldBegin()
13900 
      if ftype == TType.STOP:
13901 
        break
13902 
      if fid == 1:
13903 
        if ftype == TType.STRING:
13904 
          self.bannerName = iprot.readString();
13905 
        else:
13906 
          iprot.skip(ftype)
13907 
      else:
13908 
        iprot.skip(ftype)
13909 
      iprot.readFieldEnd()
13910 
    iprot.readStructEnd()
13911 
 
13912 
  def write(self, oprot):
13913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13915 
      return
13916 
    oprot.writeStructBegin('deleteBannerMap_args')
13917 
    if self.bannerName is not None:
13918 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13919 
      oprot.writeString(self.bannerName)
13920 
      oprot.writeFieldEnd()
13921 
    oprot.writeFieldStop()
13922 
    oprot.writeStructEnd()
13923 
 
13924 
  def validate(self):
13925 
    return
13926 
 
13927 
 
13928 
  def __repr__(self):
13929 
    L = ['%s=%r' % (key, value)
13930 
      for key, value in self.__dict__.iteritems()]
13931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13932 
 
13933 
  def __eq__(self, other):
13934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13935 
 
13936 
  def __ne__(self, other):
13937 
    return not (self == other)
13938 
 
13939 
class deleteBannerMap_result:
13940 
  """
13941 
  Attributes:
13942 
   - success
13943 
  """
13944 
 
13945 
  thrift_spec = (
13946 
    (0, TType.BOOL, 'success', None, None, ), # 0
13947 
  )
13948 
 
13949 
  def __init__(self, success=None,):
13950 
    self.success = success
13951 
 
13952 
  def read(self, iprot):
13953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13955 
      return
13956 
    iprot.readStructBegin()
13957 
    while True:
13958 
      (fname, ftype, fid) = iprot.readFieldBegin()
13959 
      if ftype == TType.STOP:
13960 
        break
13961 
      if fid == 0:
13962 
        if ftype == TType.BOOL:
13963 
          self.success = iprot.readBool();
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      else:
13967 
        iprot.skip(ftype)
13968 
      iprot.readFieldEnd()
13969 
    iprot.readStructEnd()
13970 
 
13971 
  def write(self, oprot):
13972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13974 
      return
13975 
    oprot.writeStructBegin('deleteBannerMap_result')
13976 
    if self.success is not None:
13977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13978 
      oprot.writeBool(self.success)
13979 
      oprot.writeFieldEnd()
13980 
    oprot.writeFieldStop()
13981 
    oprot.writeStructEnd()
13982 
 
13983 
  def validate(self):
13984 
    return
13985 
 
13986 
 
13987 
  def __repr__(self):
13988 
    L = ['%s=%r' % (key, value)
13989 
      for key, value in self.__dict__.iteritems()]
13990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13991 
 
13992 
  def __eq__(self, other):
13993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13994 
 
13995 
  def __ne__(self, other):
13996 
    return not (self == other)
13997 
 
13998 
class getBannerMapDetails_args:
13999 
  """
14000 
  Attributes:
14001 
   - bannerName
9155 kshitij.so 14002 
   - bannerType
6849 kshitij.so 14003 
  """
14004 
 
14005 
  thrift_spec = (
14006 
    None, # 0
14007 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14008 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14009 
  )
14010 
 
9155 kshitij.so 14011 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14012 
    self.bannerName = bannerName
9155 kshitij.so 14013 
    self.bannerType = bannerType
6849 kshitij.so 14014 
 
14015 
  def read(self, iprot):
14016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14018 
      return
14019 
    iprot.readStructBegin()
14020 
    while True:
14021 
      (fname, ftype, fid) = iprot.readFieldBegin()
14022 
      if ftype == TType.STOP:
14023 
        break
14024 
      if fid == 1:
14025 
        if ftype == TType.STRING:
14026 
          self.bannerName = iprot.readString();
14027 
        else:
14028 
          iprot.skip(ftype)
9155 kshitij.so 14029 
      elif fid == 2:
14030 
        if ftype == TType.I32:
14031 
          self.bannerType = iprot.readI32();
14032 
        else:
14033 
          iprot.skip(ftype)
6849 kshitij.so 14034 
      else:
14035 
        iprot.skip(ftype)
14036 
      iprot.readFieldEnd()
14037 
    iprot.readStructEnd()
14038 
 
14039 
  def write(self, oprot):
14040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14042 
      return
14043 
    oprot.writeStructBegin('getBannerMapDetails_args')
14044 
    if self.bannerName is not None:
14045 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14046 
      oprot.writeString(self.bannerName)
14047 
      oprot.writeFieldEnd()
9155 kshitij.so 14048 
    if self.bannerType is not None:
14049 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14050 
      oprot.writeI32(self.bannerType)
14051 
      oprot.writeFieldEnd()
6849 kshitij.so 14052 
    oprot.writeFieldStop()
14053 
    oprot.writeStructEnd()
14054 
 
14055 
  def validate(self):
14056 
    return
14057 
 
14058 
 
14059 
  def __repr__(self):
14060 
    L = ['%s=%r' % (key, value)
14061 
      for key, value in self.__dict__.iteritems()]
14062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14063 
 
14064 
  def __eq__(self, other):
14065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14066 
 
14067 
  def __ne__(self, other):
14068 
    return not (self == other)
14069 
 
14070 
class getBannerMapDetails_result:
14071 
  """
14072 
  Attributes:
14073 
   - success
14074 
  """
14075 
 
14076 
  thrift_spec = (
14077 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14078 
  )
14079 
 
14080 
  def __init__(self, success=None,):
14081 
    self.success = success
14082 
 
14083 
  def read(self, iprot):
14084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14086 
      return
14087 
    iprot.readStructBegin()
14088 
    while True:
14089 
      (fname, ftype, fid) = iprot.readFieldBegin()
14090 
      if ftype == TType.STOP:
14091 
        break
14092 
      if fid == 0:
14093 
        if ftype == TType.LIST:
14094 
          self.success = []
8590 kshitij.so 14095 
          (_etype228, _size225) = iprot.readListBegin()
14096 
          for _i229 in xrange(_size225):
14097 
            _elem230 = BannerMap()
14098 
            _elem230.read(iprot)
14099 
            self.success.append(_elem230)
6849 kshitij.so 14100 
          iprot.readListEnd()
14101 
        else:
14102 
          iprot.skip(ftype)
14103 
      else:
14104 
        iprot.skip(ftype)
14105 
      iprot.readFieldEnd()
14106 
    iprot.readStructEnd()
14107 
 
14108 
  def write(self, oprot):
14109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14111 
      return
14112 
    oprot.writeStructBegin('getBannerMapDetails_result')
14113 
    if self.success is not None:
14114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14116 
      for iter231 in self.success:
14117 
        iter231.write(oprot)
6849 kshitij.so 14118 
      oprot.writeListEnd()
14119 
      oprot.writeFieldEnd()
14120 
    oprot.writeFieldStop()
14121 
    oprot.writeStructEnd()
14122 
 
14123 
  def validate(self):
14124 
    return
14125 
 
14126 
 
14127 
  def __repr__(self):
14128 
    L = ['%s=%r' % (key, value)
14129 
      for key, value in self.__dict__.iteritems()]
14130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14131 
 
14132 
  def __eq__(self, other):
14133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14134 
 
14135 
  def __ne__(self, other):
14136 
    return not (self == other)
14137 
 
8579 kshitij.so 14138 
class addBannerUri_args:
14139 
  """
14140 
  Attributes:
14141 
   - bannerUriMappings
14142 
  """
14143 
 
14144 
  thrift_spec = (
14145 
    None, # 0
14146 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14147 
  )
14148 
 
14149 
  def __init__(self, bannerUriMappings=None,):
14150 
    self.bannerUriMappings = bannerUriMappings
14151 
 
14152 
  def read(self, iprot):
14153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14155 
      return
14156 
    iprot.readStructBegin()
14157 
    while True:
14158 
      (fname, ftype, fid) = iprot.readFieldBegin()
14159 
      if ftype == TType.STOP:
14160 
        break
14161 
      if fid == 1:
14162 
        if ftype == TType.LIST:
14163 
          self.bannerUriMappings = []
8590 kshitij.so 14164 
          (_etype235, _size232) = iprot.readListBegin()
14165 
          for _i236 in xrange(_size232):
14166 
            _elem237 = BannerUriMapping()
14167 
            _elem237.read(iprot)
14168 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14169 
          iprot.readListEnd()
14170 
        else:
14171 
          iprot.skip(ftype)
14172 
      else:
14173 
        iprot.skip(ftype)
14174 
      iprot.readFieldEnd()
14175 
    iprot.readStructEnd()
14176 
 
14177 
  def write(self, oprot):
14178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14180 
      return
14181 
    oprot.writeStructBegin('addBannerUri_args')
14182 
    if self.bannerUriMappings is not None:
14183 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14184 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14185 
      for iter238 in self.bannerUriMappings:
14186 
        iter238.write(oprot)
8579 kshitij.so 14187 
      oprot.writeListEnd()
14188 
      oprot.writeFieldEnd()
14189 
    oprot.writeFieldStop()
14190 
    oprot.writeStructEnd()
14191 
 
14192 
  def validate(self):
14193 
    return
14194 
 
14195 
 
14196 
  def __repr__(self):
14197 
    L = ['%s=%r' % (key, value)
14198 
      for key, value in self.__dict__.iteritems()]
14199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14200 
 
14201 
  def __eq__(self, other):
14202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14203 
 
14204 
  def __ne__(self, other):
14205 
    return not (self == other)
14206 
 
14207 
class addBannerUri_result:
14208 
 
14209 
  thrift_spec = (
14210 
  )
14211 
 
14212 
  def read(self, iprot):
14213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14215 
      return
14216 
    iprot.readStructBegin()
14217 
    while True:
14218 
      (fname, ftype, fid) = iprot.readFieldBegin()
14219 
      if ftype == TType.STOP:
14220 
        break
14221 
      else:
14222 
        iprot.skip(ftype)
14223 
      iprot.readFieldEnd()
14224 
    iprot.readStructEnd()
14225 
 
14226 
  def write(self, oprot):
14227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14229 
      return
14230 
    oprot.writeStructBegin('addBannerUri_result')
14231 
    oprot.writeFieldStop()
14232 
    oprot.writeStructEnd()
14233 
 
14234 
  def validate(self):
14235 
    return
14236 
 
14237 
 
14238 
  def __repr__(self):
14239 
    L = ['%s=%r' % (key, value)
14240 
      for key, value in self.__dict__.iteritems()]
14241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14242 
 
14243 
  def __eq__(self, other):
14244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14245 
 
14246 
  def __ne__(self, other):
14247 
    return not (self == other)
14248 
 
14249 
class getUriMapping_args:
14250 
  """
14251 
  Attributes:
14252 
   - bannerName
9155 kshitij.so 14253 
   - bannerType
8579 kshitij.so 14254 
  """
14255 
 
14256 
  thrift_spec = (
14257 
    None, # 0
14258 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14259 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14260 
  )
14261 
 
9155 kshitij.so 14262 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14263 
    self.bannerName = bannerName
9155 kshitij.so 14264 
    self.bannerType = bannerType
8579 kshitij.so 14265 
 
14266 
  def read(self, iprot):
14267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14269 
      return
14270 
    iprot.readStructBegin()
14271 
    while True:
14272 
      (fname, ftype, fid) = iprot.readFieldBegin()
14273 
      if ftype == TType.STOP:
14274 
        break
14275 
      if fid == 1:
14276 
        if ftype == TType.STRING:
14277 
          self.bannerName = iprot.readString();
14278 
        else:
14279 
          iprot.skip(ftype)
9155 kshitij.so 14280 
      elif fid == 2:
14281 
        if ftype == TType.I32:
14282 
          self.bannerType = iprot.readI32();
14283 
        else:
14284 
          iprot.skip(ftype)
8579 kshitij.so 14285 
      else:
14286 
        iprot.skip(ftype)
14287 
      iprot.readFieldEnd()
14288 
    iprot.readStructEnd()
14289 
 
14290 
  def write(self, oprot):
14291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14293 
      return
14294 
    oprot.writeStructBegin('getUriMapping_args')
14295 
    if self.bannerName is not None:
14296 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14297 
      oprot.writeString(self.bannerName)
14298 
      oprot.writeFieldEnd()
9155 kshitij.so 14299 
    if self.bannerType is not None:
14300 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14301 
      oprot.writeI32(self.bannerType)
14302 
      oprot.writeFieldEnd()
8579 kshitij.so 14303 
    oprot.writeFieldStop()
14304 
    oprot.writeStructEnd()
14305 
 
14306 
  def validate(self):
14307 
    return
14308 
 
14309 
 
14310 
  def __repr__(self):
14311 
    L = ['%s=%r' % (key, value)
14312 
      for key, value in self.__dict__.iteritems()]
14313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14314 
 
14315 
  def __eq__(self, other):
14316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14317 
 
14318 
  def __ne__(self, other):
14319 
    return not (self == other)
14320 
 
14321 
class getUriMapping_result:
14322 
  """
14323 
  Attributes:
14324 
   - success
14325 
  """
14326 
 
14327 
  thrift_spec = (
14328 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14329 
  )
14330 
 
14331 
  def __init__(self, success=None,):
14332 
    self.success = success
14333 
 
14334 
  def read(self, iprot):
14335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14337 
      return
14338 
    iprot.readStructBegin()
14339 
    while True:
14340 
      (fname, ftype, fid) = iprot.readFieldBegin()
14341 
      if ftype == TType.STOP:
14342 
        break
14343 
      if fid == 0:
14344 
        if ftype == TType.LIST:
14345 
          self.success = []
8590 kshitij.so 14346 
          (_etype242, _size239) = iprot.readListBegin()
14347 
          for _i243 in xrange(_size239):
14348 
            _elem244 = BannerUriMapping()
14349 
            _elem244.read(iprot)
14350 
            self.success.append(_elem244)
8579 kshitij.so 14351 
          iprot.readListEnd()
14352 
        else:
14353 
          iprot.skip(ftype)
14354 
      else:
14355 
        iprot.skip(ftype)
14356 
      iprot.readFieldEnd()
14357 
    iprot.readStructEnd()
14358 
 
14359 
  def write(self, oprot):
14360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14362 
      return
14363 
    oprot.writeStructBegin('getUriMapping_result')
14364 
    if self.success is not None:
14365 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14366 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14367 
      for iter245 in self.success:
14368 
        iter245.write(oprot)
8579 kshitij.so 14369 
      oprot.writeListEnd()
14370 
      oprot.writeFieldEnd()
14371 
    oprot.writeFieldStop()
14372 
    oprot.writeStructEnd()
14373 
 
14374 
  def validate(self):
14375 
    return
14376 
 
14377 
 
14378 
  def __repr__(self):
14379 
    L = ['%s=%r' % (key, value)
14380 
      for key, value in self.__dict__.iteritems()]
14381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14382 
 
14383 
  def __eq__(self, other):
14384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14385 
 
14386 
  def __ne__(self, other):
14387 
    return not (self == other)
14388 
 
14389 
class addCampaign_args:
14390 
  """
14391 
  Attributes:
14392 
   - campaign
14393 
  """
14394 
 
14395 
  thrift_spec = (
14396 
    None, # 0
14397 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14398 
  )
14399 
 
14400 
  def __init__(self, campaign=None,):
14401 
    self.campaign = campaign
14402 
 
14403 
  def read(self, iprot):
14404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14406 
      return
14407 
    iprot.readStructBegin()
14408 
    while True:
14409 
      (fname, ftype, fid) = iprot.readFieldBegin()
14410 
      if ftype == TType.STOP:
14411 
        break
14412 
      if fid == 1:
14413 
        if ftype == TType.STRUCT:
14414 
          self.campaign = Campaign()
14415 
          self.campaign.read(iprot)
14416 
        else:
14417 
          iprot.skip(ftype)
14418 
      else:
14419 
        iprot.skip(ftype)
14420 
      iprot.readFieldEnd()
14421 
    iprot.readStructEnd()
14422 
 
14423 
  def write(self, oprot):
14424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14426 
      return
14427 
    oprot.writeStructBegin('addCampaign_args')
14428 
    if self.campaign is not None:
14429 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14430 
      self.campaign.write(oprot)
14431 
      oprot.writeFieldEnd()
14432 
    oprot.writeFieldStop()
14433 
    oprot.writeStructEnd()
14434 
 
14435 
  def validate(self):
14436 
    return
14437 
 
14438 
 
14439 
  def __repr__(self):
14440 
    L = ['%s=%r' % (key, value)
14441 
      for key, value in self.__dict__.iteritems()]
14442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14443 
 
14444 
  def __eq__(self, other):
14445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14446 
 
14447 
  def __ne__(self, other):
14448 
    return not (self == other)
14449 
 
14450 
class addCampaign_result:
14451 
 
14452 
  thrift_spec = (
14453 
  )
14454 
 
14455 
  def read(self, iprot):
14456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14458 
      return
14459 
    iprot.readStructBegin()
14460 
    while True:
14461 
      (fname, ftype, fid) = iprot.readFieldBegin()
14462 
      if ftype == TType.STOP:
14463 
        break
14464 
      else:
14465 
        iprot.skip(ftype)
14466 
      iprot.readFieldEnd()
14467 
    iprot.readStructEnd()
14468 
 
14469 
  def write(self, oprot):
14470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14472 
      return
14473 
    oprot.writeStructBegin('addCampaign_result')
14474 
    oprot.writeFieldStop()
14475 
    oprot.writeStructEnd()
14476 
 
14477 
  def validate(self):
14478 
    return
14479 
 
14480 
 
14481 
  def __repr__(self):
14482 
    L = ['%s=%r' % (key, value)
14483 
      for key, value in self.__dict__.iteritems()]
14484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14485 
 
14486 
  def __eq__(self, other):
14487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14488 
 
14489 
  def __ne__(self, other):
14490 
    return not (self == other)
14491 
 
14492 
class getCampaigns_args:
14493 
  """
14494 
  Attributes:
14495 
   - campaignName
14496 
  """
14497 
 
14498 
  thrift_spec = (
14499 
    None, # 0
14500 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14501 
  )
14502 
 
14503 
  def __init__(self, campaignName=None,):
14504 
    self.campaignName = campaignName
14505 
 
14506 
  def read(self, iprot):
14507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14509 
      return
14510 
    iprot.readStructBegin()
14511 
    while True:
14512 
      (fname, ftype, fid) = iprot.readFieldBegin()
14513 
      if ftype == TType.STOP:
14514 
        break
14515 
      if fid == 1:
14516 
        if ftype == TType.STRING:
14517 
          self.campaignName = iprot.readString();
14518 
        else:
14519 
          iprot.skip(ftype)
14520 
      else:
14521 
        iprot.skip(ftype)
14522 
      iprot.readFieldEnd()
14523 
    iprot.readStructEnd()
14524 
 
14525 
  def write(self, oprot):
14526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14528 
      return
14529 
    oprot.writeStructBegin('getCampaigns_args')
14530 
    if self.campaignName is not None:
14531 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14532 
      oprot.writeString(self.campaignName)
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
14552 
class getCampaigns_result:
14553 
  """
14554 
  Attributes:
14555 
   - success
14556 
  """
14557 
 
14558 
  thrift_spec = (
14559 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14560 
  )
14561 
 
14562 
  def __init__(self, success=None,):
14563 
    self.success = success
14564 
 
14565 
  def read(self, iprot):
14566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14568 
      return
14569 
    iprot.readStructBegin()
14570 
    while True:
14571 
      (fname, ftype, fid) = iprot.readFieldBegin()
14572 
      if ftype == TType.STOP:
14573 
        break
14574 
      if fid == 0:
14575 
        if ftype == TType.LIST:
14576 
          self.success = []
8590 kshitij.so 14577 
          (_etype249, _size246) = iprot.readListBegin()
14578 
          for _i250 in xrange(_size246):
14579 
            _elem251 = Campaign()
14580 
            _elem251.read(iprot)
14581 
            self.success.append(_elem251)
8579 kshitij.so 14582 
          iprot.readListEnd()
14583 
        else:
14584 
          iprot.skip(ftype)
14585 
      else:
14586 
        iprot.skip(ftype)
14587 
      iprot.readFieldEnd()
14588 
    iprot.readStructEnd()
14589 
 
14590 
  def write(self, oprot):
14591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14593 
      return
14594 
    oprot.writeStructBegin('getCampaigns_result')
14595 
    if self.success is not None:
14596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14597 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14598 
      for iter252 in self.success:
14599 
        iter252.write(oprot)
8579 kshitij.so 14600 
      oprot.writeListEnd()
14601 
      oprot.writeFieldEnd()
14602 
    oprot.writeFieldStop()
14603 
    oprot.writeStructEnd()
14604 
 
14605 
  def validate(self):
14606 
    return
14607 
 
14608 
 
14609 
  def __repr__(self):
14610 
    L = ['%s=%r' % (key, value)
14611 
      for key, value in self.__dict__.iteritems()]
14612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14613 
 
14614 
  def __eq__(self, other):
14615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14616 
 
14617 
  def __ne__(self, other):
14618 
    return not (self == other)
14619 
 
14620 
class deleteCampaign_args:
14621 
  """
14622 
  Attributes:
14623 
   - campaignId
14624 
  """
14625 
 
14626 
  thrift_spec = (
14627 
    None, # 0
14628 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14629 
  )
14630 
 
14631 
  def __init__(self, campaignId=None,):
14632 
    self.campaignId = campaignId
14633 
 
14634 
  def read(self, iprot):
14635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14637 
      return
14638 
    iprot.readStructBegin()
14639 
    while True:
14640 
      (fname, ftype, fid) = iprot.readFieldBegin()
14641 
      if ftype == TType.STOP:
14642 
        break
14643 
      if fid == 1:
14644 
        if ftype == TType.I64:
14645 
          self.campaignId = iprot.readI64();
14646 
        else:
14647 
          iprot.skip(ftype)
14648 
      else:
14649 
        iprot.skip(ftype)
14650 
      iprot.readFieldEnd()
14651 
    iprot.readStructEnd()
14652 
 
14653 
  def write(self, oprot):
14654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14656 
      return
14657 
    oprot.writeStructBegin('deleteCampaign_args')
14658 
    if self.campaignId is not None:
14659 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14660 
      oprot.writeI64(self.campaignId)
14661 
      oprot.writeFieldEnd()
14662 
    oprot.writeFieldStop()
14663 
    oprot.writeStructEnd()
14664 
 
14665 
  def validate(self):
14666 
    return
14667 
 
14668 
 
14669 
  def __repr__(self):
14670 
    L = ['%s=%r' % (key, value)
14671 
      for key, value in self.__dict__.iteritems()]
14672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14673 
 
14674 
  def __eq__(self, other):
14675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14676 
 
14677 
  def __ne__(self, other):
14678 
    return not (self == other)
14679 
 
14680 
class deleteCampaign_result:
14681 
 
14682 
  thrift_spec = (
14683 
  )
14684 
 
14685 
  def read(self, iprot):
14686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14688 
      return
14689 
    iprot.readStructBegin()
14690 
    while True:
14691 
      (fname, ftype, fid) = iprot.readFieldBegin()
14692 
      if ftype == TType.STOP:
14693 
        break
14694 
      else:
14695 
        iprot.skip(ftype)
14696 
      iprot.readFieldEnd()
14697 
    iprot.readStructEnd()
14698 
 
14699 
  def write(self, oprot):
14700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14702 
      return
14703 
    oprot.writeStructBegin('deleteCampaign_result')
14704 
    oprot.writeFieldStop()
14705 
    oprot.writeStructEnd()
14706 
 
14707 
  def validate(self):
14708 
    return
14709 
 
14710 
 
14711 
  def __repr__(self):
14712 
    L = ['%s=%r' % (key, value)
14713 
      for key, value in self.__dict__.iteritems()]
14714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14715 
 
14716 
  def __eq__(self, other):
14717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14718 
 
14719 
  def __ne__(self, other):
14720 
    return not (self == other)
14721 
 
14722 
class getAllCampaigns_args:
14723 
 
14724 
  thrift_spec = (
14725 
  )
14726 
 
14727 
  def read(self, iprot):
14728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14730 
      return
14731 
    iprot.readStructBegin()
14732 
    while True:
14733 
      (fname, ftype, fid) = iprot.readFieldBegin()
14734 
      if ftype == TType.STOP:
14735 
        break
14736 
      else:
14737 
        iprot.skip(ftype)
14738 
      iprot.readFieldEnd()
14739 
    iprot.readStructEnd()
14740 
 
14741 
  def write(self, oprot):
14742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14744 
      return
14745 
    oprot.writeStructBegin('getAllCampaigns_args')
14746 
    oprot.writeFieldStop()
14747 
    oprot.writeStructEnd()
14748 
 
14749 
  def validate(self):
14750 
    return
14751 
 
14752 
 
14753 
  def __repr__(self):
14754 
    L = ['%s=%r' % (key, value)
14755 
      for key, value in self.__dict__.iteritems()]
14756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14757 
 
14758 
  def __eq__(self, other):
14759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14760 
 
14761 
  def __ne__(self, other):
14762 
    return not (self == other)
14763 
 
14764 
class getAllCampaigns_result:
14765 
  """
14766 
  Attributes:
14767 
   - success
14768 
  """
14769 
 
14770 
  thrift_spec = (
14771 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14772 
  )
14773 
 
14774 
  def __init__(self, success=None,):
14775 
    self.success = success
14776 
 
14777 
  def read(self, iprot):
14778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14780 
      return
14781 
    iprot.readStructBegin()
14782 
    while True:
14783 
      (fname, ftype, fid) = iprot.readFieldBegin()
14784 
      if ftype == TType.STOP:
14785 
        break
14786 
      if fid == 0:
14787 
        if ftype == TType.LIST:
14788 
          self.success = []
8590 kshitij.so 14789 
          (_etype256, _size253) = iprot.readListBegin()
14790 
          for _i257 in xrange(_size253):
14791 
            _elem258 = iprot.readString();
14792 
            self.success.append(_elem258)
8579 kshitij.so 14793 
          iprot.readListEnd()
14794 
        else:
14795 
          iprot.skip(ftype)
14796 
      else:
14797 
        iprot.skip(ftype)
14798 
      iprot.readFieldEnd()
14799 
    iprot.readStructEnd()
14800 
 
14801 
  def write(self, oprot):
14802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14804 
      return
14805 
    oprot.writeStructBegin('getAllCampaigns_result')
14806 
    if self.success is not None:
14807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14808 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14809 
      for iter259 in self.success:
14810 
        oprot.writeString(iter259)
8579 kshitij.so 14811 
      oprot.writeListEnd()
14812 
      oprot.writeFieldEnd()
14813 
    oprot.writeFieldStop()
14814 
    oprot.writeStructEnd()
14815 
 
14816 
  def validate(self):
14817 
    return
14818 
 
14819 
 
14820 
  def __repr__(self):
14821 
    L = ['%s=%r' % (key, value)
14822 
      for key, value in self.__dict__.iteritems()]
14823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14824 
 
14825 
  def __eq__(self, other):
14826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14827 
 
14828 
  def __ne__(self, other):
14829 
    return not (self == other)
14830 
 
9155 kshitij.so 14831 
class getActiveBannersForMobileSite_args:
14832 
 
14833 
  thrift_spec = (
14834 
  )
14835 
 
14836 
  def read(self, iprot):
14837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14839 
      return
14840 
    iprot.readStructBegin()
14841 
    while True:
14842 
      (fname, ftype, fid) = iprot.readFieldBegin()
14843 
      if ftype == TType.STOP:
14844 
        break
14845 
      else:
14846 
        iprot.skip(ftype)
14847 
      iprot.readFieldEnd()
14848 
    iprot.readStructEnd()
14849 
 
14850 
  def write(self, oprot):
14851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14853 
      return
14854 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14855 
    oprot.writeFieldStop()
14856 
    oprot.writeStructEnd()
14857 
 
14858 
  def validate(self):
14859 
    return
14860 
 
14861 
 
14862 
  def __repr__(self):
14863 
    L = ['%s=%r' % (key, value)
14864 
      for key, value in self.__dict__.iteritems()]
14865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14866 
 
14867 
  def __eq__(self, other):
14868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14869 
 
14870 
  def __ne__(self, other):
14871 
    return not (self == other)
14872 
 
14873 
class getActiveBannersForMobileSite_result:
14874 
  """
14875 
  Attributes:
14876 
   - success
14877 
  """
14878 
 
14879 
  thrift_spec = (
14880 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14881 
  )
14882 
 
14883 
  def __init__(self, success=None,):
14884 
    self.success = success
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      if fid == 0:
14896 
        if ftype == TType.MAP:
14897 
          self.success = {}
14898 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14899 
          for _i264 in xrange(_size260):
14900 
            _key265 = iprot.readString();
14901 
            _val266 = []
14902 
            (_etype270, _size267) = iprot.readListBegin()
14903 
            for _i271 in xrange(_size267):
14904 
              _elem272 = Banner()
14905 
              _elem272.read(iprot)
14906 
              _val266.append(_elem272)
14907 
            iprot.readListEnd()
14908 
            self.success[_key265] = _val266
14909 
          iprot.readMapEnd()
14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      else:
14913 
        iprot.skip(ftype)
14914 
      iprot.readFieldEnd()
14915 
    iprot.readStructEnd()
14916 
 
14917 
  def write(self, oprot):
14918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14920 
      return
14921 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14922 
    if self.success is not None:
14923 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14924 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14925 
      for kiter273,viter274 in self.success.items():
14926 
        oprot.writeString(kiter273)
14927 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14928 
        for iter275 in viter274:
14929 
          iter275.write(oprot)
14930 
        oprot.writeListEnd()
14931 
      oprot.writeMapEnd()
14932 
      oprot.writeFieldEnd()
14933 
    oprot.writeFieldStop()
14934 
    oprot.writeStructEnd()
14935 
 
14936 
  def validate(self):
14937 
    return
14938 
 
14939 
 
14940 
  def __repr__(self):
14941 
    L = ['%s=%r' % (key, value)
14942 
      for key, value in self.__dict__.iteritems()]
14943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14944 
 
14945 
  def __eq__(self, other):
14946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14947 
 
14948 
  def __ne__(self, other):
14949 
    return not (self == other)
14950 
 
5944 mandeep.dh 14951 
class deleteSimilarItem_args:
14952 
  """
14953 
  Attributes:
14954 
   - itemId
14955 
   - catalogItemId
14956 
  """
14957 
 
14958 
  thrift_spec = (
14959 
    None, # 0
14960 
    (1, TType.I64, 'itemId', None, None, ), # 1
14961 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14962 
  )
14963 
 
14964 
  def __init__(self, itemId=None, catalogItemId=None,):
14965 
    self.itemId = itemId
14966 
    self.catalogItemId = catalogItemId
14967 
 
14968 
  def read(self, iprot):
14969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14971 
      return
14972 
    iprot.readStructBegin()
14973 
    while True:
14974 
      (fname, ftype, fid) = iprot.readFieldBegin()
14975 
      if ftype == TType.STOP:
14976 
        break
14977 
      if fid == 1:
14978 
        if ftype == TType.I64:
14979 
          self.itemId = iprot.readI64();
14980 
        else:
14981 
          iprot.skip(ftype)
14982 
      elif fid == 2:
14983 
        if ftype == TType.I64:
14984 
          self.catalogItemId = iprot.readI64();
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      else:
14988 
        iprot.skip(ftype)
14989 
      iprot.readFieldEnd()
14990 
    iprot.readStructEnd()
14991 
 
14992 
  def write(self, oprot):
14993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14995 
      return
14996 
    oprot.writeStructBegin('deleteSimilarItem_args')
14997 
    if self.itemId is not None:
14998 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14999 
      oprot.writeI64(self.itemId)
15000 
      oprot.writeFieldEnd()
15001 
    if self.catalogItemId is not None:
15002 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15003 
      oprot.writeI64(self.catalogItemId)
15004 
      oprot.writeFieldEnd()
15005 
    oprot.writeFieldStop()
15006 
    oprot.writeStructEnd()
15007 
 
15008 
  def validate(self):
15009 
    return
15010 
 
15011 
 
15012 
  def __repr__(self):
15013 
    L = ['%s=%r' % (key, value)
15014 
      for key, value in self.__dict__.iteritems()]
15015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15016 
 
15017 
  def __eq__(self, other):
15018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15019 
 
15020 
  def __ne__(self, other):
15021 
    return not (self == other)
15022 
 
15023 
class deleteSimilarItem_result:
15024 
  """
15025 
  Attributes:
15026 
   - success
15027 
   - cex
15028 
  """
15029 
 
15030 
  thrift_spec = (
15031 
    (0, TType.BOOL, 'success', None, None, ), # 0
15032 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15033 
  )
15034 
 
15035 
  def __init__(self, success=None, cex=None,):
15036 
    self.success = success
15037 
    self.cex = cex
15038 
 
15039 
  def read(self, iprot):
15040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15042 
      return
15043 
    iprot.readStructBegin()
15044 
    while True:
15045 
      (fname, ftype, fid) = iprot.readFieldBegin()
15046 
      if ftype == TType.STOP:
15047 
        break
15048 
      if fid == 0:
15049 
        if ftype == TType.BOOL:
15050 
          self.success = iprot.readBool();
15051 
        else:
15052 
          iprot.skip(ftype)
15053 
      elif fid == 1:
15054 
        if ftype == TType.STRUCT:
15055 
          self.cex = CatalogServiceException()
15056 
          self.cex.read(iprot)
15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      else:
15060 
        iprot.skip(ftype)
15061 
      iprot.readFieldEnd()
15062 
    iprot.readStructEnd()
15063 
 
15064 
  def write(self, oprot):
15065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15067 
      return
15068 
    oprot.writeStructBegin('deleteSimilarItem_result')
15069 
    if self.success is not None:
15070 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15071 
      oprot.writeBool(self.success)
15072 
      oprot.writeFieldEnd()
15073 
    if self.cex is not None:
15074 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15075 
      self.cex.write(oprot)
15076 
      oprot.writeFieldEnd()
15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
15094 
 
15095 
class checkSimilarItem_args:
15096 
  """
15097 
  Attributes:
15098 
   - brand
15099 
   - modelNumber
15100 
   - modelName
15101 
   - color
15102 
  """
15103 
 
15104 
  thrift_spec = (
15105 
    None, # 0
15106 
    (1, TType.STRING, 'brand', None, None, ), # 1
15107 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15108 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15109 
    (4, TType.STRING, 'color', None, None, ), # 4
15110 
  )
15111 
 
15112 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15113 
    self.brand = brand
15114 
    self.modelNumber = modelNumber
15115 
    self.modelName = modelName
15116 
    self.color = color
15117 
 
15118 
  def read(self, iprot):
15119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15121 
      return
15122 
    iprot.readStructBegin()
15123 
    while True:
15124 
      (fname, ftype, fid) = iprot.readFieldBegin()
15125 
      if ftype == TType.STOP:
15126 
        break
15127 
      if fid == 1:
15128 
        if ftype == TType.STRING:
15129 
          self.brand = iprot.readString();
15130 
        else:
15131 
          iprot.skip(ftype)
15132 
      elif fid == 2:
15133 
        if ftype == TType.STRING:
15134 
          self.modelNumber = iprot.readString();
15135 
        else:
15136 
          iprot.skip(ftype)
15137 
      elif fid == 3:
15138 
        if ftype == TType.STRING:
15139 
          self.modelName = iprot.readString();
15140 
        else:
15141 
          iprot.skip(ftype)
15142 
      elif fid == 4:
15143 
        if ftype == TType.STRING:
15144 
          self.color = iprot.readString();
15145 
        else:
15146 
          iprot.skip(ftype)
15147 
      else:
15148 
        iprot.skip(ftype)
15149 
      iprot.readFieldEnd()
15150 
    iprot.readStructEnd()
15151 
 
15152 
  def write(self, oprot):
15153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15155 
      return
15156 
    oprot.writeStructBegin('checkSimilarItem_args')
15157 
    if self.brand is not None:
15158 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15159 
      oprot.writeString(self.brand)
15160 
      oprot.writeFieldEnd()
15161 
    if self.modelNumber is not None:
15162 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15163 
      oprot.writeString(self.modelNumber)
15164 
      oprot.writeFieldEnd()
15165 
    if self.modelName is not None:
15166 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15167 
      oprot.writeString(self.modelName)
15168 
      oprot.writeFieldEnd()
15169 
    if self.color is not None:
15170 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15171 
      oprot.writeString(self.color)
15172 
      oprot.writeFieldEnd()
15173 
    oprot.writeFieldStop()
15174 
    oprot.writeStructEnd()
15175 
 
15176 
  def validate(self):
15177 
    return
15178 
 
15179 
 
15180 
  def __repr__(self):
15181 
    L = ['%s=%r' % (key, value)
15182 
      for key, value in self.__dict__.iteritems()]
15183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15184 
 
15185 
  def __eq__(self, other):
15186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15187 
 
15188 
  def __ne__(self, other):
15189 
    return not (self == other)
15190 
 
15191 
class checkSimilarItem_result:
15192 
  """
15193 
  Attributes:
15194 
   - success
15195 
  """
15196 
 
15197 
  thrift_spec = (
15198 
    (0, TType.I64, 'success', None, None, ), # 0
15199 
  )
15200 
 
15201 
  def __init__(self, success=None,):
15202 
    self.success = success
15203 
 
15204 
  def read(self, iprot):
15205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15207 
      return
15208 
    iprot.readStructBegin()
15209 
    while True:
15210 
      (fname, ftype, fid) = iprot.readFieldBegin()
15211 
      if ftype == TType.STOP:
15212 
        break
15213 
      if fid == 0:
15214 
        if ftype == TType.I64:
15215 
          self.success = iprot.readI64();
15216 
        else:
15217 
          iprot.skip(ftype)
15218 
      else:
15219 
        iprot.skip(ftype)
15220 
      iprot.readFieldEnd()
15221 
    iprot.readStructEnd()
15222 
 
15223 
  def write(self, oprot):
15224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15226 
      return
15227 
    oprot.writeStructBegin('checkSimilarItem_result')
15228 
    if self.success is not None:
15229 
      oprot.writeFieldBegin('success', TType.I64, 0)
15230 
      oprot.writeI64(self.success)
15231 
      oprot.writeFieldEnd()
15232 
    oprot.writeFieldStop()
15233 
    oprot.writeStructEnd()
15234 
 
15235 
  def validate(self):
15236 
    return
15237 
 
15238 
 
15239 
  def __repr__(self):
15240 
    L = ['%s=%r' % (key, value)
15241 
      for key, value in self.__dict__.iteritems()]
15242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15243 
 
15244 
  def __eq__(self, other):
15245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15246 
 
15247 
  def __ne__(self, other):
15248 
    return not (self == other)
15249 
 
15250 
class validateRiskyStatus_args:
15251 
  """
15252 
  Attributes:
15253 
   - itemId
15254 
  """
15255 
 
15256 
  thrift_spec = (
15257 
    None, # 0
15258 
    (1, TType.I64, 'itemId', None, None, ), # 1
15259 
  )
15260 
 
15261 
  def __init__(self, itemId=None,):
15262 
    self.itemId = itemId
15263 
 
15264 
  def read(self, iprot):
15265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15267 
      return
15268 
    iprot.readStructBegin()
15269 
    while True:
15270 
      (fname, ftype, fid) = iprot.readFieldBegin()
15271 
      if ftype == TType.STOP:
15272 
        break
15273 
      if fid == 1:
15274 
        if ftype == TType.I64:
15275 
          self.itemId = iprot.readI64();
15276 
        else:
15277 
          iprot.skip(ftype)
15278 
      else:
15279 
        iprot.skip(ftype)
15280 
      iprot.readFieldEnd()
15281 
    iprot.readStructEnd()
15282 
 
15283 
  def write(self, oprot):
15284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15286 
      return
15287 
    oprot.writeStructBegin('validateRiskyStatus_args')
15288 
    if self.itemId is not None:
15289 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15290 
      oprot.writeI64(self.itemId)
15291 
      oprot.writeFieldEnd()
15292 
    oprot.writeFieldStop()
15293 
    oprot.writeStructEnd()
15294 
 
15295 
  def validate(self):
15296 
    return
15297 
 
15298 
 
15299 
  def __repr__(self):
15300 
    L = ['%s=%r' % (key, value)
15301 
      for key, value in self.__dict__.iteritems()]
15302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15303 
 
15304 
  def __eq__(self, other):
15305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15306 
 
15307 
  def __ne__(self, other):
15308 
    return not (self == other)
15309 
 
15310 
class validateRiskyStatus_result:
15311 
 
15312 
  thrift_spec = (
15313 
  )
15314 
 
15315 
  def read(self, iprot):
15316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15318 
      return
15319 
    iprot.readStructBegin()
15320 
    while True:
15321 
      (fname, ftype, fid) = iprot.readFieldBegin()
15322 
      if ftype == TType.STOP:
15323 
        break
15324 
      else:
15325 
        iprot.skip(ftype)
15326 
      iprot.readFieldEnd()
15327 
    iprot.readStructEnd()
15328 
 
15329 
  def write(self, oprot):
15330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15332 
      return
15333 
    oprot.writeStructBegin('validateRiskyStatus_result')
15334 
    oprot.writeFieldStop()
15335 
    oprot.writeStructEnd()
15336 
 
15337 
  def validate(self):
15338 
    return
15339 
 
15340 
 
15341 
  def __repr__(self):
15342 
    L = ['%s=%r' % (key, value)
15343 
      for key, value in self.__dict__.iteritems()]
15344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15345 
 
15346 
  def __eq__(self, other):
15347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15348 
 
15349 
  def __ne__(self, other):
15350 
    return not (self == other)
15351 
 
15352 
class changeItemRiskyFlag_args:
15353 
  """
15354 
  Attributes:
15355 
   - itemId
15356 
   - risky
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    None, # 0
15361 
    (1, TType.I64, 'itemId', None, None, ), # 1
15362 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15363 
  )
15364 
 
15365 
  def __init__(self, itemId=None, risky=None,):
15366 
    self.itemId = itemId
15367 
    self.risky = risky
15368 
 
15369 
  def read(self, iprot):
15370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15372 
      return
15373 
    iprot.readStructBegin()
15374 
    while True:
15375 
      (fname, ftype, fid) = iprot.readFieldBegin()
15376 
      if ftype == TType.STOP:
15377 
        break
15378 
      if fid == 1:
15379 
        if ftype == TType.I64:
15380 
          self.itemId = iprot.readI64();
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      elif fid == 2:
15384 
        if ftype == TType.BOOL:
15385 
          self.risky = iprot.readBool();
15386 
        else:
15387 
          iprot.skip(ftype)
15388 
      else:
15389 
        iprot.skip(ftype)
15390 
      iprot.readFieldEnd()
15391 
    iprot.readStructEnd()
15392 
 
15393 
  def write(self, oprot):
15394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15396 
      return
15397 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15398 
    if self.itemId is not None:
15399 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15400 
      oprot.writeI64(self.itemId)
15401 
      oprot.writeFieldEnd()
15402 
    if self.risky is not None:
15403 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15404 
      oprot.writeBool(self.risky)
15405 
      oprot.writeFieldEnd()
15406 
    oprot.writeFieldStop()
15407 
    oprot.writeStructEnd()
15408 
 
15409 
  def validate(self):
15410 
    return
15411 
 
15412 
 
15413 
  def __repr__(self):
15414 
    L = ['%s=%r' % (key, value)
15415 
      for key, value in self.__dict__.iteritems()]
15416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15417 
 
15418 
  def __eq__(self, other):
15419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15420 
 
15421 
  def __ne__(self, other):
15422 
    return not (self == other)
15423 
 
15424 
class changeItemRiskyFlag_result:
15425 
 
15426 
  thrift_spec = (
15427 
  )
15428 
 
15429 
  def read(self, iprot):
15430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15432 
      return
15433 
    iprot.readStructBegin()
15434 
    while True:
15435 
      (fname, ftype, fid) = iprot.readFieldBegin()
15436 
      if ftype == TType.STOP:
15437 
        break
15438 
      else:
15439 
        iprot.skip(ftype)
15440 
      iprot.readFieldEnd()
15441 
    iprot.readStructEnd()
15442 
 
15443 
  def write(self, oprot):
15444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15446 
      return
15447 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15448 
    oprot.writeFieldStop()
15449 
    oprot.writeStructEnd()
15450 
 
15451 
  def validate(self):
15452 
    return
15453 
 
15454 
 
15455 
  def __repr__(self):
15456 
    L = ['%s=%r' % (key, value)
15457 
      for key, value in self.__dict__.iteritems()]
15458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15459 
 
15460 
  def __eq__(self, other):
15461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15462 
 
15463 
  def __ne__(self, other):
15464 
    return not (self == other)
15465 
 
15466 
class getItemsByRiskyFlag_args:
15467 
 
15468 
  thrift_spec = (
15469 
  )
15470 
 
15471 
  def read(self, iprot):
15472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15474 
      return
15475 
    iprot.readStructBegin()
15476 
    while True:
15477 
      (fname, ftype, fid) = iprot.readFieldBegin()
15478 
      if ftype == TType.STOP:
15479 
        break
15480 
      else:
15481 
        iprot.skip(ftype)
15482 
      iprot.readFieldEnd()
15483 
    iprot.readStructEnd()
15484 
 
15485 
  def write(self, oprot):
15486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15488 
      return
15489 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15490 
    oprot.writeFieldStop()
15491 
    oprot.writeStructEnd()
15492 
 
15493 
  def validate(self):
15494 
    return
15495 
 
15496 
 
15497 
  def __repr__(self):
15498 
    L = ['%s=%r' % (key, value)
15499 
      for key, value in self.__dict__.iteritems()]
15500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15501 
 
15502 
  def __eq__(self, other):
15503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15504 
 
15505 
  def __ne__(self, other):
15506 
    return not (self == other)
15507 
 
15508 
class getItemsByRiskyFlag_result:
15509 
  """
15510 
  Attributes:
15511 
   - success
15512 
  """
15513 
 
15514 
  thrift_spec = (
15515 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15516 
  )
15517 
 
15518 
  def __init__(self, success=None,):
15519 
    self.success = success
15520 
 
15521 
  def read(self, iprot):
15522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15524 
      return
15525 
    iprot.readStructBegin()
15526 
    while True:
15527 
      (fname, ftype, fid) = iprot.readFieldBegin()
15528 
      if ftype == TType.STOP:
15529 
        break
15530 
      if fid == 0:
15531 
        if ftype == TType.LIST:
15532 
          self.success = []
9155 kshitij.so 15533 
          (_etype279, _size276) = iprot.readListBegin()
15534 
          for _i280 in xrange(_size276):
15535 
            _elem281 = Item()
15536 
            _elem281.read(iprot)
15537 
            self.success.append(_elem281)
5944 mandeep.dh 15538 
          iprot.readListEnd()
15539 
        else:
15540 
          iprot.skip(ftype)
15541 
      else:
15542 
        iprot.skip(ftype)
15543 
      iprot.readFieldEnd()
15544 
    iprot.readStructEnd()
15545 
 
15546 
  def write(self, oprot):
15547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15549 
      return
15550 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15551 
    if self.success is not None:
15552 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15553 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15554 
      for iter282 in self.success:
15555 
        iter282.write(oprot)
5944 mandeep.dh 15556 
      oprot.writeListEnd()
15557 
      oprot.writeFieldEnd()
15558 
    oprot.writeFieldStop()
15559 
    oprot.writeStructEnd()
15560 
 
15561 
  def validate(self):
15562 
    return
15563 
 
15564 
 
15565 
  def __repr__(self):
15566 
    L = ['%s=%r' % (key, value)
15567 
      for key, value in self.__dict__.iteritems()]
15568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15569 
 
15570 
  def __eq__(self, other):
15571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15572 
 
15573 
  def __ne__(self, other):
15574 
    return not (self == other)
15575 
 
15576 
class getItemsForMasterSheet_args:
15577 
  """
15578 
  Attributes:
15579 
   - category
15580 
   - brand
15581 
  """
15582 
 
15583 
  thrift_spec = (
15584 
    None, # 0
15585 
    (1, TType.STRING, 'category', None, None, ), # 1
15586 
    (2, TType.STRING, 'brand', None, None, ), # 2
15587 
  )
15588 
 
15589 
  def __init__(self, category=None, brand=None,):
15590 
    self.category = category
15591 
    self.brand = brand
15592 
 
15593 
  def read(self, iprot):
15594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15596 
      return
15597 
    iprot.readStructBegin()
15598 
    while True:
15599 
      (fname, ftype, fid) = iprot.readFieldBegin()
15600 
      if ftype == TType.STOP:
15601 
        break
15602 
      if fid == 1:
15603 
        if ftype == TType.STRING:
15604 
          self.category = iprot.readString();
15605 
        else:
15606 
          iprot.skip(ftype)
15607 
      elif fid == 2:
15608 
        if ftype == TType.STRING:
15609 
          self.brand = iprot.readString();
15610 
        else:
15611 
          iprot.skip(ftype)
15612 
      else:
15613 
        iprot.skip(ftype)
15614 
      iprot.readFieldEnd()
15615 
    iprot.readStructEnd()
15616 
 
15617 
  def write(self, oprot):
15618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15620 
      return
15621 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15622 
    if self.category is not None:
15623 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15624 
      oprot.writeString(self.category)
15625 
      oprot.writeFieldEnd()
15626 
    if self.brand is not None:
15627 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15628 
      oprot.writeString(self.brand)
15629 
      oprot.writeFieldEnd()
15630 
    oprot.writeFieldStop()
15631 
    oprot.writeStructEnd()
15632 
 
15633 
  def validate(self):
15634 
    return
15635 
 
15636 
 
15637 
  def __repr__(self):
15638 
    L = ['%s=%r' % (key, value)
15639 
      for key, value in self.__dict__.iteritems()]
15640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15641 
 
15642 
  def __eq__(self, other):
15643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15644 
 
15645 
  def __ne__(self, other):
15646 
    return not (self == other)
15647 
 
15648 
class getItemsForMasterSheet_result:
15649 
  """
15650 
  Attributes:
15651 
   - success
15652 
  """
15653 
 
15654 
  thrift_spec = (
15655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15656 
  )
15657 
 
15658 
  def __init__(self, success=None,):
15659 
    self.success = success
15660 
 
15661 
  def read(self, iprot):
15662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15664 
      return
15665 
    iprot.readStructBegin()
15666 
    while True:
15667 
      (fname, ftype, fid) = iprot.readFieldBegin()
15668 
      if ftype == TType.STOP:
15669 
        break
15670 
      if fid == 0:
15671 
        if ftype == TType.LIST:
15672 
          self.success = []
9155 kshitij.so 15673 
          (_etype286, _size283) = iprot.readListBegin()
15674 
          for _i287 in xrange(_size283):
15675 
            _elem288 = Item()
15676 
            _elem288.read(iprot)
15677 
            self.success.append(_elem288)
5944 mandeep.dh 15678 
          iprot.readListEnd()
15679 
        else:
15680 
          iprot.skip(ftype)
15681 
      else:
15682 
        iprot.skip(ftype)
15683 
      iprot.readFieldEnd()
15684 
    iprot.readStructEnd()
15685 
 
15686 
  def write(self, oprot):
15687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15689 
      return
15690 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15691 
    if self.success is not None:
15692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15693 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15694 
      for iter289 in self.success:
15695 
        iter289.write(oprot)
5944 mandeep.dh 15696 
      oprot.writeListEnd()
15697 
      oprot.writeFieldEnd()
15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
15715 
 
15716 
class getSimilarItemsCatalogIds_args:
15717 
  """
15718 
  Attributes:
15719 
   - beginIndex
15720 
   - totalItems
15721 
   - itemId
15722 
  """
15723 
 
15724 
  thrift_spec = (
15725 
    None, # 0
15726 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15727 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15728 
    (3, TType.I64, 'itemId', None, None, ), # 3
15729 
  )
15730 
 
15731 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15732 
    self.beginIndex = beginIndex
15733 
    self.totalItems = totalItems
15734 
    self.itemId = itemId
15735 
 
15736 
  def read(self, iprot):
15737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15739 
      return
15740 
    iprot.readStructBegin()
15741 
    while True:
15742 
      (fname, ftype, fid) = iprot.readFieldBegin()
15743 
      if ftype == TType.STOP:
15744 
        break
15745 
      if fid == 1:
15746 
        if ftype == TType.I64:
15747 
          self.beginIndex = iprot.readI64();
15748 
        else:
15749 
          iprot.skip(ftype)
15750 
      elif fid == 2:
15751 
        if ftype == TType.I64:
15752 
          self.totalItems = iprot.readI64();
15753 
        else:
15754 
          iprot.skip(ftype)
15755 
      elif fid == 3:
15756 
        if ftype == TType.I64:
15757 
          self.itemId = iprot.readI64();
15758 
        else:
15759 
          iprot.skip(ftype)
15760 
      else:
15761 
        iprot.skip(ftype)
15762 
      iprot.readFieldEnd()
15763 
    iprot.readStructEnd()
15764 
 
15765 
  def write(self, oprot):
15766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15768 
      return
15769 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15770 
    if self.beginIndex is not None:
15771 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15772 
      oprot.writeI64(self.beginIndex)
15773 
      oprot.writeFieldEnd()
15774 
    if self.totalItems is not None:
15775 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15776 
      oprot.writeI64(self.totalItems)
15777 
      oprot.writeFieldEnd()
15778 
    if self.itemId is not None:
15779 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15780 
      oprot.writeI64(self.itemId)
15781 
      oprot.writeFieldEnd()
15782 
    oprot.writeFieldStop()
15783 
    oprot.writeStructEnd()
15784 
 
15785 
  def validate(self):
15786 
    return
15787 
 
15788 
 
15789 
  def __repr__(self):
15790 
    L = ['%s=%r' % (key, value)
15791 
      for key, value in self.__dict__.iteritems()]
15792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15793 
 
15794 
  def __eq__(self, other):
15795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15796 
 
15797 
  def __ne__(self, other):
15798 
    return not (self == other)
15799 
 
15800 
class getSimilarItemsCatalogIds_result:
15801 
  """
15802 
  Attributes:
15803 
   - success
15804 
  """
15805 
 
15806 
  thrift_spec = (
15807 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15808 
  )
15809 
 
15810 
  def __init__(self, success=None,):
15811 
    self.success = success
15812 
 
15813 
  def read(self, iprot):
15814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15816 
      return
15817 
    iprot.readStructBegin()
15818 
    while True:
15819 
      (fname, ftype, fid) = iprot.readFieldBegin()
15820 
      if ftype == TType.STOP:
15821 
        break
15822 
      if fid == 0:
15823 
        if ftype == TType.LIST:
15824 
          self.success = []
9155 kshitij.so 15825 
          (_etype293, _size290) = iprot.readListBegin()
15826 
          for _i294 in xrange(_size290):
15827 
            _elem295 = iprot.readI64();
15828 
            self.success.append(_elem295)
5944 mandeep.dh 15829 
          iprot.readListEnd()
15830 
        else:
15831 
          iprot.skip(ftype)
15832 
      else:
15833 
        iprot.skip(ftype)
15834 
      iprot.readFieldEnd()
15835 
    iprot.readStructEnd()
15836 
 
15837 
  def write(self, oprot):
15838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15840 
      return
15841 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15842 
    if self.success is not None:
15843 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15844 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15845 
      for iter296 in self.success:
15846 
        oprot.writeI64(iter296)
5944 mandeep.dh 15847 
      oprot.writeListEnd()
15848 
      oprot.writeFieldEnd()
15849 
    oprot.writeFieldStop()
15850 
    oprot.writeStructEnd()
15851 
 
15852 
  def validate(self):
15853 
    return
15854 
 
15855 
 
15856 
  def __repr__(self):
15857 
    L = ['%s=%r' % (key, value)
15858 
      for key, value in self.__dict__.iteritems()]
15859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15860 
 
15861 
  def __eq__(self, other):
15862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15863 
 
15864 
  def __ne__(self, other):
15865 
    return not (self == other)
15866 
 
15867 
class addProductNotification_args:
15868 
  """
15869 
  Attributes:
15870 
   - itemId
15871 
   - email
15872 
  """
15873 
 
15874 
  thrift_spec = None
15875 
  def __init__(self, itemId=None, email=None,):
15876 
    self.itemId = itemId
15877 
    self.email = email
15878 
 
15879 
  def read(self, iprot):
15880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15882 
      return
15883 
    iprot.readStructBegin()
15884 
    while True:
15885 
      (fname, ftype, fid) = iprot.readFieldBegin()
15886 
      if ftype == TType.STOP:
15887 
        break
15888 
      if fid == -1:
15889 
        if ftype == TType.I64:
15890 
          self.itemId = iprot.readI64();
15891 
        else:
15892 
          iprot.skip(ftype)
15893 
      elif fid == -2:
15894 
        if ftype == TType.STRING:
15895 
          self.email = iprot.readString();
15896 
        else:
15897 
          iprot.skip(ftype)
15898 
      else:
15899 
        iprot.skip(ftype)
15900 
      iprot.readFieldEnd()
15901 
    iprot.readStructEnd()
15902 
 
15903 
  def write(self, oprot):
15904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15906 
      return
15907 
    oprot.writeStructBegin('addProductNotification_args')
15908 
    if self.email is not None:
15909 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15910 
      oprot.writeString(self.email)
15911 
      oprot.writeFieldEnd()
15912 
    if self.itemId is not None:
15913 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15914 
      oprot.writeI64(self.itemId)
15915 
      oprot.writeFieldEnd()
15916 
    oprot.writeFieldStop()
15917 
    oprot.writeStructEnd()
15918 
 
15919 
  def validate(self):
15920 
    return
15921 
 
15922 
 
15923 
  def __repr__(self):
15924 
    L = ['%s=%r' % (key, value)
15925 
      for key, value in self.__dict__.iteritems()]
15926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15927 
 
15928 
  def __eq__(self, other):
15929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15930 
 
15931 
  def __ne__(self, other):
15932 
    return not (self == other)
15933 
 
15934 
class addProductNotification_result:
15935 
  """
15936 
  Attributes:
15937 
   - success
15938 
  """
15939 
 
15940 
  thrift_spec = (
15941 
    (0, TType.BOOL, 'success', None, None, ), # 0
15942 
  )
15943 
 
15944 
  def __init__(self, success=None,):
15945 
    self.success = success
15946 
 
15947 
  def read(self, iprot):
15948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15950 
      return
15951 
    iprot.readStructBegin()
15952 
    while True:
15953 
      (fname, ftype, fid) = iprot.readFieldBegin()
15954 
      if ftype == TType.STOP:
15955 
        break
15956 
      if fid == 0:
15957 
        if ftype == TType.BOOL:
15958 
          self.success = iprot.readBool();
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('addProductNotification_result')
15971 
    if self.success is not None:
15972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15973 
      oprot.writeBool(self.success)
15974 
      oprot.writeFieldEnd()
15975 
    oprot.writeFieldStop()
15976 
    oprot.writeStructEnd()
15977 
 
15978 
  def validate(self):
15979 
    return
15980 
 
15981 
 
15982 
  def __repr__(self):
15983 
    L = ['%s=%r' % (key, value)
15984 
      for key, value in self.__dict__.iteritems()]
15985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15986 
 
15987 
  def __eq__(self, other):
15988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15989 
 
15990 
  def __ne__(self, other):
15991 
    return not (self == other)
15992 
 
15993 
class sendProductNotifications_args:
15994 
 
15995 
  thrift_spec = (
15996 
  )
15997 
 
15998 
  def read(self, iprot):
15999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16001 
      return
16002 
    iprot.readStructBegin()
16003 
    while True:
16004 
      (fname, ftype, fid) = iprot.readFieldBegin()
16005 
      if ftype == TType.STOP:
16006 
        break
16007 
      else:
16008 
        iprot.skip(ftype)
16009 
      iprot.readFieldEnd()
16010 
    iprot.readStructEnd()
16011 
 
16012 
  def write(self, oprot):
16013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16015 
      return
16016 
    oprot.writeStructBegin('sendProductNotifications_args')
16017 
    oprot.writeFieldStop()
16018 
    oprot.writeStructEnd()
16019 
 
16020 
  def validate(self):
16021 
    return
16022 
 
16023 
 
16024 
  def __repr__(self):
16025 
    L = ['%s=%r' % (key, value)
16026 
      for key, value in self.__dict__.iteritems()]
16027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16028 
 
16029 
  def __eq__(self, other):
16030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16031 
 
16032 
  def __ne__(self, other):
16033 
    return not (self == other)
16034 
 
16035 
class sendProductNotifications_result:
16036 
  """
16037 
  Attributes:
16038 
   - success
16039 
  """
16040 
 
16041 
  thrift_spec = (
16042 
    (0, TType.BOOL, 'success', None, None, ), # 0
16043 
  )
16044 
 
16045 
  def __init__(self, success=None,):
16046 
    self.success = success
16047 
 
16048 
  def read(self, iprot):
16049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16051 
      return
16052 
    iprot.readStructBegin()
16053 
    while True:
16054 
      (fname, ftype, fid) = iprot.readFieldBegin()
16055 
      if ftype == TType.STOP:
16056 
        break
16057 
      if fid == 0:
16058 
        if ftype == TType.BOOL:
16059 
          self.success = iprot.readBool();
16060 
        else:
16061 
          iprot.skip(ftype)
16062 
      else:
16063 
        iprot.skip(ftype)
16064 
      iprot.readFieldEnd()
16065 
    iprot.readStructEnd()
16066 
 
16067 
  def write(self, oprot):
16068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16070 
      return
16071 
    oprot.writeStructBegin('sendProductNotifications_result')
16072 
    if self.success is not None:
16073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16074 
      oprot.writeBool(self.success)
16075 
      oprot.writeFieldEnd()
16076 
    oprot.writeFieldStop()
16077 
    oprot.writeStructEnd()
16078 
 
16079 
  def validate(self):
16080 
    return
16081 
 
16082 
 
16083 
  def __repr__(self):
16084 
    L = ['%s=%r' % (key, value)
16085 
      for key, value in self.__dict__.iteritems()]
16086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16087 
 
16088 
  def __eq__(self, other):
16089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16090 
 
16091 
  def __ne__(self, other):
16092 
    return not (self == other)
16093 
 
16094 
class getAllBrandsByCategory_args:
16095 
  """
16096 
  Attributes:
16097 
   - categoryId
16098 
  """
16099 
 
16100 
  thrift_spec = (
16101 
    None, # 0
16102 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16103 
  )
16104 
 
16105 
  def __init__(self, categoryId=None,):
16106 
    self.categoryId = categoryId
16107 
 
16108 
  def read(self, iprot):
16109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16111 
      return
16112 
    iprot.readStructBegin()
16113 
    while True:
16114 
      (fname, ftype, fid) = iprot.readFieldBegin()
16115 
      if ftype == TType.STOP:
16116 
        break
16117 
      if fid == 1:
16118 
        if ftype == TType.I64:
16119 
          self.categoryId = iprot.readI64();
16120 
        else:
16121 
          iprot.skip(ftype)
16122 
      else:
16123 
        iprot.skip(ftype)
16124 
      iprot.readFieldEnd()
16125 
    iprot.readStructEnd()
16126 
 
16127 
  def write(self, oprot):
16128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16130 
      return
16131 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16132 
    if self.categoryId is not None:
16133 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16134 
      oprot.writeI64(self.categoryId)
16135 
      oprot.writeFieldEnd()
16136 
    oprot.writeFieldStop()
16137 
    oprot.writeStructEnd()
16138 
 
16139 
  def validate(self):
16140 
    return
16141 
 
16142 
 
16143 
  def __repr__(self):
16144 
    L = ['%s=%r' % (key, value)
16145 
      for key, value in self.__dict__.iteritems()]
16146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16147 
 
16148 
  def __eq__(self, other):
16149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16150 
 
16151 
  def __ne__(self, other):
16152 
    return not (self == other)
16153 
 
16154 
class getAllBrandsByCategory_result:
16155 
  """
16156 
  Attributes:
16157 
   - success
16158 
  """
16159 
 
16160 
  thrift_spec = (
16161 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16162 
  )
16163 
 
16164 
  def __init__(self, success=None,):
16165 
    self.success = success
16166 
 
16167 
  def read(self, iprot):
16168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16170 
      return
16171 
    iprot.readStructBegin()
16172 
    while True:
16173 
      (fname, ftype, fid) = iprot.readFieldBegin()
16174 
      if ftype == TType.STOP:
16175 
        break
16176 
      if fid == 0:
16177 
        if ftype == TType.LIST:
16178 
          self.success = []
9155 kshitij.so 16179 
          (_etype300, _size297) = iprot.readListBegin()
16180 
          for _i301 in xrange(_size297):
16181 
            _elem302 = iprot.readString();
16182 
            self.success.append(_elem302)
5944 mandeep.dh 16183 
          iprot.readListEnd()
16184 
        else:
16185 
          iprot.skip(ftype)
16186 
      else:
16187 
        iprot.skip(ftype)
16188 
      iprot.readFieldEnd()
16189 
    iprot.readStructEnd()
16190 
 
16191 
  def write(self, oprot):
16192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16194 
      return
16195 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16196 
    if self.success is not None:
16197 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16198 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16199 
      for iter303 in self.success:
16200 
        oprot.writeString(iter303)
5944 mandeep.dh 16201 
      oprot.writeListEnd()
16202 
      oprot.writeFieldEnd()
16203 
    oprot.writeFieldStop()
16204 
    oprot.writeStructEnd()
16205 
 
16206 
  def validate(self):
16207 
    return
16208 
 
16209 
 
16210 
  def __repr__(self):
16211 
    L = ['%s=%r' % (key, value)
16212 
      for key, value in self.__dict__.iteritems()]
16213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16214 
 
16215 
  def __eq__(self, other):
16216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16217 
 
16218 
  def __ne__(self, other):
16219 
    return not (self == other)
16220 
 
16221 
class getAllBrands_args:
16222 
 
16223 
  thrift_spec = (
16224 
  )
16225 
 
16226 
  def read(self, iprot):
16227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16229 
      return
16230 
    iprot.readStructBegin()
16231 
    while True:
16232 
      (fname, ftype, fid) = iprot.readFieldBegin()
16233 
      if ftype == TType.STOP:
16234 
        break
16235 
      else:
16236 
        iprot.skip(ftype)
16237 
      iprot.readFieldEnd()
16238 
    iprot.readStructEnd()
16239 
 
16240 
  def write(self, oprot):
16241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16243 
      return
16244 
    oprot.writeStructBegin('getAllBrands_args')
16245 
    oprot.writeFieldStop()
16246 
    oprot.writeStructEnd()
16247 
 
16248 
  def validate(self):
16249 
    return
16250 
 
16251 
 
16252 
  def __repr__(self):
16253 
    L = ['%s=%r' % (key, value)
16254 
      for key, value in self.__dict__.iteritems()]
16255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16256 
 
16257 
  def __eq__(self, other):
16258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16259 
 
16260 
  def __ne__(self, other):
16261 
    return not (self == other)
16262 
 
16263 
class getAllBrands_result:
16264 
  """
16265 
  Attributes:
16266 
   - success
16267 
  """
16268 
 
16269 
  thrift_spec = (
16270 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16271 
  )
16272 
 
16273 
  def __init__(self, success=None,):
16274 
    self.success = success
16275 
 
16276 
  def read(self, iprot):
16277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16279 
      return
16280 
    iprot.readStructBegin()
16281 
    while True:
16282 
      (fname, ftype, fid) = iprot.readFieldBegin()
16283 
      if ftype == TType.STOP:
16284 
        break
16285 
      if fid == 0:
16286 
        if ftype == TType.LIST:
16287 
          self.success = []
9155 kshitij.so 16288 
          (_etype307, _size304) = iprot.readListBegin()
16289 
          for _i308 in xrange(_size304):
16290 
            _elem309 = iprot.readString();
16291 
            self.success.append(_elem309)
5944 mandeep.dh 16292 
          iprot.readListEnd()
16293 
        else:
16294 
          iprot.skip(ftype)
16295 
      else:
16296 
        iprot.skip(ftype)
16297 
      iprot.readFieldEnd()
16298 
    iprot.readStructEnd()
16299 
 
16300 
  def write(self, oprot):
16301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16303 
      return
16304 
    oprot.writeStructBegin('getAllBrands_result')
16305 
    if self.success is not None:
16306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16307 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16308 
      for iter310 in self.success:
16309 
        oprot.writeString(iter310)
5944 mandeep.dh 16310 
      oprot.writeListEnd()
16311 
      oprot.writeFieldEnd()
16312 
    oprot.writeFieldStop()
16313 
    oprot.writeStructEnd()
16314 
 
16315 
  def validate(self):
16316 
    return
16317 
 
16318 
 
16319 
  def __repr__(self):
16320 
    L = ['%s=%r' % (key, value)
16321 
      for key, value in self.__dict__.iteritems()]
16322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16323 
 
16324 
  def __eq__(self, other):
16325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16326 
 
16327 
  def __ne__(self, other):
16328 
    return not (self == other)
16329 
 
16330 
class getAllSources_args:
16331 
 
16332 
  thrift_spec = (
16333 
  )
16334 
 
16335 
  def read(self, iprot):
16336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16338 
      return
16339 
    iprot.readStructBegin()
16340 
    while True:
16341 
      (fname, ftype, fid) = iprot.readFieldBegin()
16342 
      if ftype == TType.STOP:
16343 
        break
16344 
      else:
16345 
        iprot.skip(ftype)
16346 
      iprot.readFieldEnd()
16347 
    iprot.readStructEnd()
16348 
 
16349 
  def write(self, oprot):
16350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16352 
      return
16353 
    oprot.writeStructBegin('getAllSources_args')
16354 
    oprot.writeFieldStop()
16355 
    oprot.writeStructEnd()
16356 
 
16357 
  def validate(self):
16358 
    return
16359 
 
16360 
 
16361 
  def __repr__(self):
16362 
    L = ['%s=%r' % (key, value)
16363 
      for key, value in self.__dict__.iteritems()]
16364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16365 
 
16366 
  def __eq__(self, other):
16367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16368 
 
16369 
  def __ne__(self, other):
16370 
    return not (self == other)
16371 
 
16372 
class getAllSources_result:
16373 
  """
16374 
  Attributes:
16375 
   - success
16376 
  """
16377 
 
16378 
  thrift_spec = (
16379 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16380 
  )
16381 
 
16382 
  def __init__(self, success=None,):
16383 
    self.success = success
16384 
 
16385 
  def read(self, iprot):
16386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16388 
      return
16389 
    iprot.readStructBegin()
16390 
    while True:
16391 
      (fname, ftype, fid) = iprot.readFieldBegin()
16392 
      if ftype == TType.STOP:
16393 
        break
16394 
      if fid == 0:
16395 
        if ftype == TType.LIST:
16396 
          self.success = []
9155 kshitij.so 16397 
          (_etype314, _size311) = iprot.readListBegin()
16398 
          for _i315 in xrange(_size311):
16399 
            _elem316 = Source()
16400 
            _elem316.read(iprot)
16401 
            self.success.append(_elem316)
5944 mandeep.dh 16402 
          iprot.readListEnd()
16403 
        else:
16404 
          iprot.skip(ftype)
16405 
      else:
16406 
        iprot.skip(ftype)
16407 
      iprot.readFieldEnd()
16408 
    iprot.readStructEnd()
16409 
 
16410 
  def write(self, oprot):
16411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16413 
      return
16414 
    oprot.writeStructBegin('getAllSources_result')
16415 
    if self.success is not None:
16416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16417 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16418 
      for iter317 in self.success:
16419 
        iter317.write(oprot)
5944 mandeep.dh 16420 
      oprot.writeListEnd()
16421 
      oprot.writeFieldEnd()
16422 
    oprot.writeFieldStop()
16423 
    oprot.writeStructEnd()
16424 
 
16425 
  def validate(self):
16426 
    return
16427 
 
16428 
 
16429 
  def __repr__(self):
16430 
    L = ['%s=%r' % (key, value)
16431 
      for key, value in self.__dict__.iteritems()]
16432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16433 
 
16434 
  def __eq__(self, other):
16435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16436 
 
16437 
  def __ne__(self, other):
16438 
    return not (self == other)
16439 
 
16440 
class getItemPricingBySource_args:
16441 
  """
16442 
  Attributes:
16443 
   - itemId
16444 
   - sourceId
16445 
  """
16446 
 
16447 
  thrift_spec = (
16448 
    None, # 0
16449 
    (1, TType.I64, 'itemId', None, None, ), # 1
16450 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16451 
  )
16452 
 
16453 
  def __init__(self, itemId=None, sourceId=None,):
16454 
    self.itemId = itemId
16455 
    self.sourceId = sourceId
16456 
 
16457 
  def read(self, iprot):
16458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16460 
      return
16461 
    iprot.readStructBegin()
16462 
    while True:
16463 
      (fname, ftype, fid) = iprot.readFieldBegin()
16464 
      if ftype == TType.STOP:
16465 
        break
16466 
      if fid == 1:
16467 
        if ftype == TType.I64:
16468 
          self.itemId = iprot.readI64();
16469 
        else:
16470 
          iprot.skip(ftype)
16471 
      elif fid == 2:
16472 
        if ftype == TType.I64:
16473 
          self.sourceId = iprot.readI64();
16474 
        else:
16475 
          iprot.skip(ftype)
16476 
      else:
16477 
        iprot.skip(ftype)
16478 
      iprot.readFieldEnd()
16479 
    iprot.readStructEnd()
16480 
 
16481 
  def write(self, oprot):
16482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16484 
      return
16485 
    oprot.writeStructBegin('getItemPricingBySource_args')
16486 
    if self.itemId is not None:
16487 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16488 
      oprot.writeI64(self.itemId)
16489 
      oprot.writeFieldEnd()
16490 
    if self.sourceId is not None:
16491 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16492 
      oprot.writeI64(self.sourceId)
16493 
      oprot.writeFieldEnd()
16494 
    oprot.writeFieldStop()
16495 
    oprot.writeStructEnd()
16496 
 
16497 
  def validate(self):
16498 
    return
16499 
 
16500 
 
16501 
  def __repr__(self):
16502 
    L = ['%s=%r' % (key, value)
16503 
      for key, value in self.__dict__.iteritems()]
16504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16505 
 
16506 
  def __eq__(self, other):
16507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16508 
 
16509 
  def __ne__(self, other):
16510 
    return not (self == other)
16511 
 
16512 
class getItemPricingBySource_result:
16513 
  """
16514 
  Attributes:
16515 
   - success
16516 
   - cex
16517 
  """
16518 
 
16519 
  thrift_spec = (
16520 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16521 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16522 
  )
16523 
 
16524 
  def __init__(self, success=None, cex=None,):
16525 
    self.success = success
16526 
    self.cex = cex
16527 
 
16528 
  def read(self, iprot):
16529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16531 
      return
16532 
    iprot.readStructBegin()
16533 
    while True:
16534 
      (fname, ftype, fid) = iprot.readFieldBegin()
16535 
      if ftype == TType.STOP:
16536 
        break
16537 
      if fid == 0:
16538 
        if ftype == TType.STRUCT:
16539 
          self.success = SourceItemPricing()
16540 
          self.success.read(iprot)
16541 
        else:
16542 
          iprot.skip(ftype)
16543 
      elif fid == 1:
16544 
        if ftype == TType.STRUCT:
16545 
          self.cex = CatalogServiceException()
16546 
          self.cex.read(iprot)
16547 
        else:
16548 
          iprot.skip(ftype)
16549 
      else:
16550 
        iprot.skip(ftype)
16551 
      iprot.readFieldEnd()
16552 
    iprot.readStructEnd()
16553 
 
16554 
  def write(self, oprot):
16555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16557 
      return
16558 
    oprot.writeStructBegin('getItemPricingBySource_result')
16559 
    if self.success is not None:
16560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16561 
      self.success.write(oprot)
16562 
      oprot.writeFieldEnd()
16563 
    if self.cex is not None:
16564 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16565 
      self.cex.write(oprot)
16566 
      oprot.writeFieldEnd()
16567 
    oprot.writeFieldStop()
16568 
    oprot.writeStructEnd()
16569 
 
16570 
  def validate(self):
16571 
    return
16572 
 
16573 
 
16574 
  def __repr__(self):
16575 
    L = ['%s=%r' % (key, value)
16576 
      for key, value in self.__dict__.iteritems()]
16577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16578 
 
16579 
  def __eq__(self, other):
16580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16581 
 
16582 
  def __ne__(self, other):
16583 
    return not (self == other)
16584 
 
16585 
class addSourceItemPricing_args:
16586 
  """
16587 
  Attributes:
16588 
   - sourceItemPricing
16589 
  """
16590 
 
16591 
  thrift_spec = (
16592 
    None, # 0
16593 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16594 
  )
16595 
 
16596 
  def __init__(self, sourceItemPricing=None,):
16597 
    self.sourceItemPricing = sourceItemPricing
16598 
 
16599 
  def read(self, iprot):
16600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16602 
      return
16603 
    iprot.readStructBegin()
16604 
    while True:
16605 
      (fname, ftype, fid) = iprot.readFieldBegin()
16606 
      if ftype == TType.STOP:
16607 
        break
16608 
      if fid == 1:
16609 
        if ftype == TType.STRUCT:
16610 
          self.sourceItemPricing = SourceItemPricing()
16611 
          self.sourceItemPricing.read(iprot)
16612 
        else:
16613 
          iprot.skip(ftype)
16614 
      else:
16615 
        iprot.skip(ftype)
16616 
      iprot.readFieldEnd()
16617 
    iprot.readStructEnd()
16618 
 
16619 
  def write(self, oprot):
16620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16622 
      return
16623 
    oprot.writeStructBegin('addSourceItemPricing_args')
16624 
    if self.sourceItemPricing is not None:
16625 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16626 
      self.sourceItemPricing.write(oprot)
16627 
      oprot.writeFieldEnd()
16628 
    oprot.writeFieldStop()
16629 
    oprot.writeStructEnd()
16630 
 
16631 
  def validate(self):
16632 
    return
16633 
 
16634 
 
16635 
  def __repr__(self):
16636 
    L = ['%s=%r' % (key, value)
16637 
      for key, value in self.__dict__.iteritems()]
16638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16639 
 
16640 
  def __eq__(self, other):
16641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16642 
 
16643 
  def __ne__(self, other):
16644 
    return not (self == other)
16645 
 
16646 
class addSourceItemPricing_result:
16647 
  """
16648 
  Attributes:
16649 
   - cex
16650 
  """
16651 
 
16652 
  thrift_spec = (
16653 
    None, # 0
16654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16655 
  )
16656 
 
16657 
  def __init__(self, cex=None,):
16658 
    self.cex = cex
16659 
 
16660 
  def read(self, iprot):
16661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16663 
      return
16664 
    iprot.readStructBegin()
16665 
    while True:
16666 
      (fname, ftype, fid) = iprot.readFieldBegin()
16667 
      if ftype == TType.STOP:
16668 
        break
16669 
      if fid == 1:
16670 
        if ftype == TType.STRUCT:
16671 
          self.cex = CatalogServiceException()
16672 
          self.cex.read(iprot)
16673 
        else:
16674 
          iprot.skip(ftype)
16675 
      else:
16676 
        iprot.skip(ftype)
16677 
      iprot.readFieldEnd()
16678 
    iprot.readStructEnd()
16679 
 
16680 
  def write(self, oprot):
16681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16683 
      return
16684 
    oprot.writeStructBegin('addSourceItemPricing_result')
16685 
    if self.cex is not None:
16686 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16687 
      self.cex.write(oprot)
16688 
      oprot.writeFieldEnd()
16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
16706 
 
16707 
class getAllSourcePricing_args:
16708 
  """
16709 
  Attributes:
16710 
   - itemId
16711 
  """
16712 
 
16713 
  thrift_spec = (
16714 
    None, # 0
16715 
    (1, TType.I64, 'itemId', None, None, ), # 1
16716 
  )
16717 
 
16718 
  def __init__(self, itemId=None,):
16719 
    self.itemId = itemId
16720 
 
16721 
  def read(self, iprot):
16722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16724 
      return
16725 
    iprot.readStructBegin()
16726 
    while True:
16727 
      (fname, ftype, fid) = iprot.readFieldBegin()
16728 
      if ftype == TType.STOP:
16729 
        break
16730 
      if fid == 1:
16731 
        if ftype == TType.I64:
16732 
          self.itemId = iprot.readI64();
16733 
        else:
16734 
          iprot.skip(ftype)
16735 
      else:
16736 
        iprot.skip(ftype)
16737 
      iprot.readFieldEnd()
16738 
    iprot.readStructEnd()
16739 
 
16740 
  def write(self, oprot):
16741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16743 
      return
16744 
    oprot.writeStructBegin('getAllSourcePricing_args')
16745 
    if self.itemId is not None:
16746 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16747 
      oprot.writeI64(self.itemId)
16748 
      oprot.writeFieldEnd()
16749 
    oprot.writeFieldStop()
16750 
    oprot.writeStructEnd()
16751 
 
16752 
  def validate(self):
16753 
    return
16754 
 
16755 
 
16756 
  def __repr__(self):
16757 
    L = ['%s=%r' % (key, value)
16758 
      for key, value in self.__dict__.iteritems()]
16759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16760 
 
16761 
  def __eq__(self, other):
16762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16763 
 
16764 
  def __ne__(self, other):
16765 
    return not (self == other)
16766 
 
16767 
class getAllSourcePricing_result:
16768 
  """
16769 
  Attributes:
16770 
   - success
16771 
   - cex
16772 
  """
16773 
 
16774 
  thrift_spec = (
16775 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16776 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16777 
  )
16778 
 
16779 
  def __init__(self, success=None, cex=None,):
16780 
    self.success = success
16781 
    self.cex = cex
16782 
 
16783 
  def read(self, iprot):
16784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16786 
      return
16787 
    iprot.readStructBegin()
16788 
    while True:
16789 
      (fname, ftype, fid) = iprot.readFieldBegin()
16790 
      if ftype == TType.STOP:
16791 
        break
16792 
      if fid == 0:
16793 
        if ftype == TType.LIST:
16794 
          self.success = []
9155 kshitij.so 16795 
          (_etype321, _size318) = iprot.readListBegin()
16796 
          for _i322 in xrange(_size318):
16797 
            _elem323 = SourceItemPricing()
16798 
            _elem323.read(iprot)
16799 
            self.success.append(_elem323)
5944 mandeep.dh 16800 
          iprot.readListEnd()
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      elif fid == 1:
16804 
        if ftype == TType.STRUCT:
16805 
          self.cex = CatalogServiceException()
16806 
          self.cex.read(iprot)
16807 
        else:
16808 
          iprot.skip(ftype)
16809 
      else:
16810 
        iprot.skip(ftype)
16811 
      iprot.readFieldEnd()
16812 
    iprot.readStructEnd()
16813 
 
16814 
  def write(self, oprot):
16815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16817 
      return
16818 
    oprot.writeStructBegin('getAllSourcePricing_result')
16819 
    if self.success is not None:
16820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16822 
      for iter324 in self.success:
16823 
        iter324.write(oprot)
5944 mandeep.dh 16824 
      oprot.writeListEnd()
16825 
      oprot.writeFieldEnd()
16826 
    if self.cex is not None:
16827 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16828 
      self.cex.write(oprot)
16829 
      oprot.writeFieldEnd()
16830 
    oprot.writeFieldStop()
16831 
    oprot.writeStructEnd()
16832 
 
16833 
  def validate(self):
16834 
    return
16835 
 
16836 
 
16837 
  def __repr__(self):
16838 
    L = ['%s=%r' % (key, value)
16839 
      for key, value in self.__dict__.iteritems()]
16840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16841 
 
16842 
  def __eq__(self, other):
16843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16844 
 
16845 
  def __ne__(self, other):
16846 
    return not (self == other)
16847 
 
16848 
class getItemForSource_args:
16849 
  """
16850 
  Attributes:
16851 
   - item_id
16852 
   - sourceId
16853 
  """
16854 
 
16855 
  thrift_spec = (
16856 
    None, # 0
16857 
    (1, TType.I64, 'item_id', None, None, ), # 1
16858 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16859 
  )
16860 
 
16861 
  def __init__(self, item_id=None, sourceId=None,):
16862 
    self.item_id = item_id
16863 
    self.sourceId = sourceId
16864 
 
16865 
  def read(self, iprot):
16866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16868 
      return
16869 
    iprot.readStructBegin()
16870 
    while True:
16871 
      (fname, ftype, fid) = iprot.readFieldBegin()
16872 
      if ftype == TType.STOP:
16873 
        break
16874 
      if fid == 1:
16875 
        if ftype == TType.I64:
16876 
          self.item_id = iprot.readI64();
16877 
        else:
16878 
          iprot.skip(ftype)
16879 
      elif fid == 2:
16880 
        if ftype == TType.I64:
16881 
          self.sourceId = iprot.readI64();
16882 
        else:
16883 
          iprot.skip(ftype)
16884 
      else:
16885 
        iprot.skip(ftype)
16886 
      iprot.readFieldEnd()
16887 
    iprot.readStructEnd()
16888 
 
16889 
  def write(self, oprot):
16890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16892 
      return
16893 
    oprot.writeStructBegin('getItemForSource_args')
16894 
    if self.item_id is not None:
16895 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16896 
      oprot.writeI64(self.item_id)
16897 
      oprot.writeFieldEnd()
16898 
    if self.sourceId is not None:
16899 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16900 
      oprot.writeI64(self.sourceId)
16901 
      oprot.writeFieldEnd()
16902 
    oprot.writeFieldStop()
16903 
    oprot.writeStructEnd()
16904 
 
16905 
  def validate(self):
16906 
    return
16907 
 
16908 
 
16909 
  def __repr__(self):
16910 
    L = ['%s=%r' % (key, value)
16911 
      for key, value in self.__dict__.iteritems()]
16912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16913 
 
16914 
  def __eq__(self, other):
16915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16916 
 
16917 
  def __ne__(self, other):
16918 
    return not (self == other)
16919 
 
16920 
class getItemForSource_result:
16921 
  """
16922 
  Attributes:
16923 
   - success
16924 
   - cex
16925 
  """
16926 
 
16927 
  thrift_spec = (
16928 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16929 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16930 
  )
16931 
 
16932 
  def __init__(self, success=None, cex=None,):
16933 
    self.success = success
16934 
    self.cex = cex
16935 
 
16936 
  def read(self, iprot):
16937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16939 
      return
16940 
    iprot.readStructBegin()
16941 
    while True:
16942 
      (fname, ftype, fid) = iprot.readFieldBegin()
16943 
      if ftype == TType.STOP:
16944 
        break
16945 
      if fid == 0:
16946 
        if ftype == TType.STRUCT:
16947 
          self.success = Item()
16948 
          self.success.read(iprot)
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      elif fid == 1:
16952 
        if ftype == TType.STRUCT:
16953 
          self.cex = CatalogServiceException()
16954 
          self.cex.read(iprot)
16955 
        else:
16956 
          iprot.skip(ftype)
16957 
      else:
16958 
        iprot.skip(ftype)
16959 
      iprot.readFieldEnd()
16960 
    iprot.readStructEnd()
16961 
 
16962 
  def write(self, oprot):
16963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16965 
      return
16966 
    oprot.writeStructBegin('getItemForSource_result')
16967 
    if self.success is not None:
16968 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16969 
      self.success.write(oprot)
16970 
      oprot.writeFieldEnd()
16971 
    if self.cex is not None:
16972 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16973 
      self.cex.write(oprot)
16974 
      oprot.writeFieldEnd()
16975 
    oprot.writeFieldStop()
16976 
    oprot.writeStructEnd()
16977 
 
16978 
  def validate(self):
16979 
    return
16980 
 
16981 
 
16982 
  def __repr__(self):
16983 
    L = ['%s=%r' % (key, value)
16984 
      for key, value in self.__dict__.iteritems()]
16985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16986 
 
16987 
  def __eq__(self, other):
16988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16989 
 
16990 
  def __ne__(self, other):
16991 
    return not (self == other)
16992 
 
16993 
class searchItemsInRange_args:
16994 
  """
16995 
  Attributes:
16996 
   - searchTerms
16997 
   - offset
16998 
   - limit
16999 
  """
17000 
 
17001 
  thrift_spec = (
17002 
    None, # 0
17003 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17004 
    (2, TType.I64, 'offset', None, None, ), # 2
17005 
    (3, TType.I64, 'limit', None, None, ), # 3
17006 
  )
17007 
 
17008 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17009 
    self.searchTerms = searchTerms
17010 
    self.offset = offset
17011 
    self.limit = limit
17012 
 
17013 
  def read(self, iprot):
17014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17016 
      return
17017 
    iprot.readStructBegin()
17018 
    while True:
17019 
      (fname, ftype, fid) = iprot.readFieldBegin()
17020 
      if ftype == TType.STOP:
17021 
        break
17022 
      if fid == 1:
17023 
        if ftype == TType.LIST:
17024 
          self.searchTerms = []
9155 kshitij.so 17025 
          (_etype328, _size325) = iprot.readListBegin()
17026 
          for _i329 in xrange(_size325):
17027 
            _elem330 = iprot.readString();
17028 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17029 
          iprot.readListEnd()
17030 
        else:
17031 
          iprot.skip(ftype)
17032 
      elif fid == 2:
17033 
        if ftype == TType.I64:
17034 
          self.offset = iprot.readI64();
17035 
        else:
17036 
          iprot.skip(ftype)
17037 
      elif fid == 3:
17038 
        if ftype == TType.I64:
17039 
          self.limit = iprot.readI64();
17040 
        else:
17041 
          iprot.skip(ftype)
17042 
      else:
17043 
        iprot.skip(ftype)
17044 
      iprot.readFieldEnd()
17045 
    iprot.readStructEnd()
17046 
 
17047 
  def write(self, oprot):
17048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17050 
      return
17051 
    oprot.writeStructBegin('searchItemsInRange_args')
17052 
    if self.searchTerms is not None:
17053 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17054 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17055 
      for iter331 in self.searchTerms:
17056 
        oprot.writeString(iter331)
5944 mandeep.dh 17057 
      oprot.writeListEnd()
17058 
      oprot.writeFieldEnd()
17059 
    if self.offset is not None:
17060 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17061 
      oprot.writeI64(self.offset)
17062 
      oprot.writeFieldEnd()
17063 
    if self.limit is not None:
17064 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17065 
      oprot.writeI64(self.limit)
17066 
      oprot.writeFieldEnd()
17067 
    oprot.writeFieldStop()
17068 
    oprot.writeStructEnd()
17069 
 
17070 
  def validate(self):
17071 
    return
17072 
 
17073 
 
17074 
  def __repr__(self):
17075 
    L = ['%s=%r' % (key, value)
17076 
      for key, value in self.__dict__.iteritems()]
17077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17078 
 
17079 
  def __eq__(self, other):
17080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17081 
 
17082 
  def __ne__(self, other):
17083 
    return not (self == other)
17084 
 
17085 
class searchItemsInRange_result:
17086 
  """
17087 
  Attributes:
17088 
   - success
17089 
  """
17090 
 
17091 
  thrift_spec = (
17092 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17093 
  )
17094 
 
17095 
  def __init__(self, success=None,):
17096 
    self.success = success
17097 
 
17098 
  def read(self, iprot):
17099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17101 
      return
17102 
    iprot.readStructBegin()
17103 
    while True:
17104 
      (fname, ftype, fid) = iprot.readFieldBegin()
17105 
      if ftype == TType.STOP:
17106 
        break
17107 
      if fid == 0:
17108 
        if ftype == TType.LIST:
17109 
          self.success = []
9155 kshitij.so 17110 
          (_etype335, _size332) = iprot.readListBegin()
17111 
          for _i336 in xrange(_size332):
17112 
            _elem337 = Item()
17113 
            _elem337.read(iprot)
17114 
            self.success.append(_elem337)
5944 mandeep.dh 17115 
          iprot.readListEnd()
17116 
        else:
17117 
          iprot.skip(ftype)
17118 
      else:
17119 
        iprot.skip(ftype)
17120 
      iprot.readFieldEnd()
17121 
    iprot.readStructEnd()
17122 
 
17123 
  def write(self, oprot):
17124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17126 
      return
17127 
    oprot.writeStructBegin('searchItemsInRange_result')
17128 
    if self.success is not None:
17129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17130 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17131 
      for iter338 in self.success:
17132 
        iter338.write(oprot)
5944 mandeep.dh 17133 
      oprot.writeListEnd()
17134 
      oprot.writeFieldEnd()
17135 
    oprot.writeFieldStop()
17136 
    oprot.writeStructEnd()
17137 
 
17138 
  def validate(self):
17139 
    return
17140 
 
17141 
 
17142 
  def __repr__(self):
17143 
    L = ['%s=%r' % (key, value)
17144 
      for key, value in self.__dict__.iteritems()]
17145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17146 
 
17147 
  def __eq__(self, other):
17148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17149 
 
17150 
  def __ne__(self, other):
17151 
    return not (self == other)
17152 
 
17153 
class getSearchResultCount_args:
17154 
  """
17155 
  Attributes:
17156 
   - searchTerms
17157 
  """
17158 
 
17159 
  thrift_spec = (
17160 
    None, # 0
17161 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17162 
  )
17163 
 
17164 
  def __init__(self, searchTerms=None,):
17165 
    self.searchTerms = searchTerms
17166 
 
17167 
  def read(self, iprot):
17168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17170 
      return
17171 
    iprot.readStructBegin()
17172 
    while True:
17173 
      (fname, ftype, fid) = iprot.readFieldBegin()
17174 
      if ftype == TType.STOP:
17175 
        break
17176 
      if fid == 1:
17177 
        if ftype == TType.LIST:
17178 
          self.searchTerms = []
9155 kshitij.so 17179 
          (_etype342, _size339) = iprot.readListBegin()
17180 
          for _i343 in xrange(_size339):
17181 
            _elem344 = iprot.readString();
17182 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17183 
          iprot.readListEnd()
17184 
        else:
17185 
          iprot.skip(ftype)
17186 
      else:
17187 
        iprot.skip(ftype)
17188 
      iprot.readFieldEnd()
17189 
    iprot.readStructEnd()
17190 
 
17191 
  def write(self, oprot):
17192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17194 
      return
17195 
    oprot.writeStructBegin('getSearchResultCount_args')
17196 
    if self.searchTerms is not None:
17197 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17198 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17199 
      for iter345 in self.searchTerms:
17200 
        oprot.writeString(iter345)
5944 mandeep.dh 17201 
      oprot.writeListEnd()
17202 
      oprot.writeFieldEnd()
17203 
    oprot.writeFieldStop()
17204 
    oprot.writeStructEnd()
17205 
 
17206 
  def validate(self):
17207 
    return
17208 
 
17209 
 
17210 
  def __repr__(self):
17211 
    L = ['%s=%r' % (key, value)
17212 
      for key, value in self.__dict__.iteritems()]
17213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17214 
 
17215 
  def __eq__(self, other):
17216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17217 
 
17218 
  def __ne__(self, other):
17219 
    return not (self == other)
17220 
 
17221 
class getSearchResultCount_result:
17222 
  """
17223 
  Attributes:
17224 
   - success
17225 
  """
17226 
 
17227 
  thrift_spec = (
17228 
    (0, TType.I32, 'success', None, None, ), # 0
17229 
  )
17230 
 
17231 
  def __init__(self, success=None,):
17232 
    self.success = success
17233 
 
17234 
  def read(self, iprot):
17235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17237 
      return
17238 
    iprot.readStructBegin()
17239 
    while True:
17240 
      (fname, ftype, fid) = iprot.readFieldBegin()
17241 
      if ftype == TType.STOP:
17242 
        break
17243 
      if fid == 0:
17244 
        if ftype == TType.I32:
17245 
          self.success = iprot.readI32();
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      else:
17249 
        iprot.skip(ftype)
17250 
      iprot.readFieldEnd()
17251 
    iprot.readStructEnd()
17252 
 
17253 
  def write(self, oprot):
17254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17256 
      return
17257 
    oprot.writeStructBegin('getSearchResultCount_result')
17258 
    if self.success is not None:
17259 
      oprot.writeFieldBegin('success', TType.I32, 0)
17260 
      oprot.writeI32(self.success)
17261 
      oprot.writeFieldEnd()
17262 
    oprot.writeFieldStop()
17263 
    oprot.writeStructEnd()
17264 
 
17265 
  def validate(self):
17266 
    return
17267 
 
17268 
 
17269 
  def __repr__(self):
17270 
    L = ['%s=%r' % (key, value)
17271 
      for key, value in self.__dict__.iteritems()]
17272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17273 
 
17274 
  def __eq__(self, other):
17275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17276 
 
17277 
  def __ne__(self, other):
17278 
    return not (self == other)
17279 
 
17280 
class getProductNotifications_args:
17281 
  """
17282 
  Attributes:
17283 
   - startDateTime
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    None, # 0
17288 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17289 
  )
17290 
 
17291 
  def __init__(self, startDateTime=None,):
17292 
    self.startDateTime = startDateTime
17293 
 
17294 
  def read(self, iprot):
17295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17297 
      return
17298 
    iprot.readStructBegin()
17299 
    while True:
17300 
      (fname, ftype, fid) = iprot.readFieldBegin()
17301 
      if ftype == TType.STOP:
17302 
        break
17303 
      if fid == 1:
17304 
        if ftype == TType.I64:
17305 
          self.startDateTime = iprot.readI64();
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('getProductNotifications_args')
17318 
    if self.startDateTime is not None:
17319 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17320 
      oprot.writeI64(self.startDateTime)
17321 
      oprot.writeFieldEnd()
17322 
    oprot.writeFieldStop()
17323 
    oprot.writeStructEnd()
17324 
 
17325 
  def validate(self):
17326 
    return
17327 
 
17328 
 
17329 
  def __repr__(self):
17330 
    L = ['%s=%r' % (key, value)
17331 
      for key, value in self.__dict__.iteritems()]
17332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17333 
 
17334 
  def __eq__(self, other):
17335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17336 
 
17337 
  def __ne__(self, other):
17338 
    return not (self == other)
17339 
 
17340 
class getProductNotifications_result:
17341 
  """
17342 
  Attributes:
17343 
   - success
17344 
  """
17345 
 
17346 
  thrift_spec = (
17347 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17348 
  )
17349 
 
17350 
  def __init__(self, success=None,):
17351 
    self.success = success
17352 
 
17353 
  def read(self, iprot):
17354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17356 
      return
17357 
    iprot.readStructBegin()
17358 
    while True:
17359 
      (fname, ftype, fid) = iprot.readFieldBegin()
17360 
      if ftype == TType.STOP:
17361 
        break
17362 
      if fid == 0:
17363 
        if ftype == TType.LIST:
17364 
          self.success = []
9155 kshitij.so 17365 
          (_etype349, _size346) = iprot.readListBegin()
17366 
          for _i350 in xrange(_size346):
17367 
            _elem351 = ProductNotificationRequest()
17368 
            _elem351.read(iprot)
17369 
            self.success.append(_elem351)
5944 mandeep.dh 17370 
          iprot.readListEnd()
17371 
        else:
17372 
          iprot.skip(ftype)
17373 
      else:
17374 
        iprot.skip(ftype)
17375 
      iprot.readFieldEnd()
17376 
    iprot.readStructEnd()
17377 
 
17378 
  def write(self, oprot):
17379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17381 
      return
17382 
    oprot.writeStructBegin('getProductNotifications_result')
17383 
    if self.success is not None:
17384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17386 
      for iter352 in self.success:
17387 
        iter352.write(oprot)
5944 mandeep.dh 17388 
      oprot.writeListEnd()
17389 
      oprot.writeFieldEnd()
17390 
    oprot.writeFieldStop()
17391 
    oprot.writeStructEnd()
17392 
 
17393 
  def validate(self):
17394 
    return
17395 
 
17396 
 
17397 
  def __repr__(self):
17398 
    L = ['%s=%r' % (key, value)
17399 
      for key, value in self.__dict__.iteritems()]
17400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17401 
 
17402 
  def __eq__(self, other):
17403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17404 
 
17405 
  def __ne__(self, other):
17406 
    return not (self == other)
17407 
 
17408 
class getProductNotificationRequestCount_args:
17409 
  """
17410 
  Attributes:
17411 
   - startDateTime
7897 amar.kumar 17412 
   - categoryId
5944 mandeep.dh 17413 
  """
17414 
 
17415 
  thrift_spec = (
17416 
    None, # 0
17417 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17418 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17419 
  )
17420 
 
7897 amar.kumar 17421 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17422 
    self.startDateTime = startDateTime
7897 amar.kumar 17423 
    self.categoryId = categoryId
5944 mandeep.dh 17424 
 
17425 
  def read(self, iprot):
17426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17428 
      return
17429 
    iprot.readStructBegin()
17430 
    while True:
17431 
      (fname, ftype, fid) = iprot.readFieldBegin()
17432 
      if ftype == TType.STOP:
17433 
        break
17434 
      if fid == 1:
17435 
        if ftype == TType.I64:
17436 
          self.startDateTime = iprot.readI64();
17437 
        else:
17438 
          iprot.skip(ftype)
7897 amar.kumar 17439 
      elif fid == 2:
17440 
        if ftype == TType.I64:
17441 
          self.categoryId = iprot.readI64();
17442 
        else:
17443 
          iprot.skip(ftype)
5944 mandeep.dh 17444 
      else:
17445 
        iprot.skip(ftype)
17446 
      iprot.readFieldEnd()
17447 
    iprot.readStructEnd()
17448 
 
17449 
  def write(self, oprot):
17450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17452 
      return
17453 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17454 
    if self.startDateTime is not None:
17455 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17456 
      oprot.writeI64(self.startDateTime)
17457 
      oprot.writeFieldEnd()
7897 amar.kumar 17458 
    if self.categoryId is not None:
17459 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17460 
      oprot.writeI64(self.categoryId)
17461 
      oprot.writeFieldEnd()
5944 mandeep.dh 17462 
    oprot.writeFieldStop()
17463 
    oprot.writeStructEnd()
17464 
 
17465 
  def validate(self):
17466 
    return
17467 
 
17468 
 
17469 
  def __repr__(self):
17470 
    L = ['%s=%r' % (key, value)
17471 
      for key, value in self.__dict__.iteritems()]
17472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17473 
 
17474 
  def __eq__(self, other):
17475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17476 
 
17477 
  def __ne__(self, other):
17478 
    return not (self == other)
17479 
 
17480 
class getProductNotificationRequestCount_result:
17481 
  """
17482 
  Attributes:
17483 
   - success
17484 
  """
17485 
 
17486 
  thrift_spec = (
17487 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17488 
  )
17489 
 
17490 
  def __init__(self, success=None,):
17491 
    self.success = success
17492 
 
17493 
  def read(self, iprot):
17494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17496 
      return
17497 
    iprot.readStructBegin()
17498 
    while True:
17499 
      (fname, ftype, fid) = iprot.readFieldBegin()
17500 
      if ftype == TType.STOP:
17501 
        break
17502 
      if fid == 0:
17503 
        if ftype == TType.LIST:
17504 
          self.success = []
9155 kshitij.so 17505 
          (_etype356, _size353) = iprot.readListBegin()
17506 
          for _i357 in xrange(_size353):
17507 
            _elem358 = ProductNotificationRequestCount()
17508 
            _elem358.read(iprot)
17509 
            self.success.append(_elem358)
5944 mandeep.dh 17510 
          iprot.readListEnd()
17511 
        else:
17512 
          iprot.skip(ftype)
17513 
      else:
17514 
        iprot.skip(ftype)
17515 
      iprot.readFieldEnd()
17516 
    iprot.readStructEnd()
17517 
 
17518 
  def write(self, oprot):
17519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17521 
      return
17522 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17523 
    if self.success is not None:
17524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17526 
      for iter359 in self.success:
17527 
        iter359.write(oprot)
5944 mandeep.dh 17528 
      oprot.writeListEnd()
17529 
      oprot.writeFieldEnd()
17530 
    oprot.writeFieldStop()
17531 
    oprot.writeStructEnd()
17532 
 
17533 
  def validate(self):
17534 
    return
17535 
 
17536 
 
17537 
  def __repr__(self):
17538 
    L = ['%s=%r' % (key, value)
17539 
      for key, value in self.__dict__.iteritems()]
17540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17541 
 
17542 
  def __eq__(self, other):
17543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17544 
 
17545 
  def __ne__(self, other):
17546 
    return not (self == other)
17547 
 
17548 
class addAuthorizationLog_args:
17549 
  """
17550 
  Attributes:
17551 
   - itemId
17552 
   - username
17553 
   - reason
17554 
  """
17555 
 
17556 
  thrift_spec = (
17557 
    None, # 0
17558 
    (1, TType.I64, 'itemId', None, None, ), # 1
17559 
    (2, TType.STRING, 'username', None, None, ), # 2
17560 
    (3, TType.STRING, 'reason', None, None, ), # 3
17561 
  )
17562 
 
17563 
  def __init__(self, itemId=None, username=None, reason=None,):
17564 
    self.itemId = itemId
17565 
    self.username = username
17566 
    self.reason = reason
17567 
 
17568 
  def read(self, iprot):
17569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17571 
      return
17572 
    iprot.readStructBegin()
17573 
    while True:
17574 
      (fname, ftype, fid) = iprot.readFieldBegin()
17575 
      if ftype == TType.STOP:
17576 
        break
17577 
      if fid == 1:
17578 
        if ftype == TType.I64:
17579 
          self.itemId = iprot.readI64();
17580 
        else:
17581 
          iprot.skip(ftype)
17582 
      elif fid == 2:
17583 
        if ftype == TType.STRING:
17584 
          self.username = iprot.readString();
17585 
        else:
17586 
          iprot.skip(ftype)
17587 
      elif fid == 3:
17588 
        if ftype == TType.STRING:
17589 
          self.reason = iprot.readString();
17590 
        else:
17591 
          iprot.skip(ftype)
17592 
      else:
17593 
        iprot.skip(ftype)
17594 
      iprot.readFieldEnd()
17595 
    iprot.readStructEnd()
17596 
 
17597 
  def write(self, oprot):
17598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17600 
      return
17601 
    oprot.writeStructBegin('addAuthorizationLog_args')
17602 
    if self.itemId is not None:
17603 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17604 
      oprot.writeI64(self.itemId)
17605 
      oprot.writeFieldEnd()
17606 
    if self.username is not None:
17607 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17608 
      oprot.writeString(self.username)
17609 
      oprot.writeFieldEnd()
17610 
    if self.reason is not None:
17611 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17612 
      oprot.writeString(self.reason)
17613 
      oprot.writeFieldEnd()
17614 
    oprot.writeFieldStop()
17615 
    oprot.writeStructEnd()
17616 
 
17617 
  def validate(self):
17618 
    return
17619 
 
17620 
 
17621 
  def __repr__(self):
17622 
    L = ['%s=%r' % (key, value)
17623 
      for key, value in self.__dict__.iteritems()]
17624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17625 
 
17626 
  def __eq__(self, other):
17627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17628 
 
17629 
  def __ne__(self, other):
17630 
    return not (self == other)
17631 
 
17632 
class addAuthorizationLog_result:
17633 
  """
17634 
  Attributes:
17635 
   - success
17636 
   - cex
17637 
  """
17638 
 
17639 
  thrift_spec = (
17640 
    (0, TType.BOOL, 'success', None, None, ), # 0
17641 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17642 
  )
17643 
 
17644 
  def __init__(self, success=None, cex=None,):
17645 
    self.success = success
17646 
    self.cex = cex
17647 
 
17648 
  def read(self, iprot):
17649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17651 
      return
17652 
    iprot.readStructBegin()
17653 
    while True:
17654 
      (fname, ftype, fid) = iprot.readFieldBegin()
17655 
      if ftype == TType.STOP:
17656 
        break
17657 
      if fid == 0:
17658 
        if ftype == TType.BOOL:
17659 
          self.success = iprot.readBool();
17660 
        else:
17661 
          iprot.skip(ftype)
17662 
      elif fid == 1:
17663 
        if ftype == TType.STRUCT:
17664 
          self.cex = CatalogServiceException()
17665 
          self.cex.read(iprot)
17666 
        else:
17667 
          iprot.skip(ftype)
17668 
      else:
17669 
        iprot.skip(ftype)
17670 
      iprot.readFieldEnd()
17671 
    iprot.readStructEnd()
17672 
 
17673 
  def write(self, oprot):
17674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17676 
      return
17677 
    oprot.writeStructBegin('addAuthorizationLog_result')
17678 
    if self.success is not None:
17679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17680 
      oprot.writeBool(self.success)
17681 
      oprot.writeFieldEnd()
17682 
    if self.cex is not None:
17683 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17684 
      self.cex.write(oprot)
17685 
      oprot.writeFieldEnd()
17686 
    oprot.writeFieldStop()
17687 
    oprot.writeStructEnd()
17688 
 
17689 
  def validate(self):
17690 
    return
17691 
 
17692 
 
17693 
  def __repr__(self):
17694 
    L = ['%s=%r' % (key, value)
17695 
      for key, value in self.__dict__.iteritems()]
17696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17697 
 
17698 
  def __eq__(self, other):
17699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17700 
 
17701 
  def __ne__(self, other):
17702 
    return not (self == other)
17703 
 
17704 
class addupdateVoucherForItem_args:
17705 
  """
17706 
  Attributes:
17707 
   - catalog_item_id
17708 
   - voucherType
17709 
   - voucherAmount
17710 
  """
17711 
 
17712 
  thrift_spec = (
17713 
    None, # 0
17714 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17715 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17716 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17717 
  )
17718 
 
17719 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17720 
    self.catalog_item_id = catalog_item_id
17721 
    self.voucherType = voucherType
17722 
    self.voucherAmount = voucherAmount
17723 
 
17724 
  def read(self, iprot):
17725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17727 
      return
17728 
    iprot.readStructBegin()
17729 
    while True:
17730 
      (fname, ftype, fid) = iprot.readFieldBegin()
17731 
      if ftype == TType.STOP:
17732 
        break
17733 
      if fid == 1:
17734 
        if ftype == TType.I64:
17735 
          self.catalog_item_id = iprot.readI64();
17736 
        else:
17737 
          iprot.skip(ftype)
17738 
      elif fid == 2:
17739 
        if ftype == TType.I64:
17740 
          self.voucherType = iprot.readI64();
17741 
        else:
17742 
          iprot.skip(ftype)
17743 
      elif fid == 3:
17744 
        if ftype == TType.I64:
17745 
          self.voucherAmount = iprot.readI64();
17746 
        else:
17747 
          iprot.skip(ftype)
17748 
      else:
17749 
        iprot.skip(ftype)
17750 
      iprot.readFieldEnd()
17751 
    iprot.readStructEnd()
17752 
 
17753 
  def write(self, oprot):
17754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17756 
      return
17757 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17758 
    if self.catalog_item_id is not None:
17759 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17760 
      oprot.writeI64(self.catalog_item_id)
17761 
      oprot.writeFieldEnd()
17762 
    if self.voucherType is not None:
17763 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17764 
      oprot.writeI64(self.voucherType)
17765 
      oprot.writeFieldEnd()
17766 
    if self.voucherAmount is not None:
17767 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17768 
      oprot.writeI64(self.voucherAmount)
17769 
      oprot.writeFieldEnd()
17770 
    oprot.writeFieldStop()
17771 
    oprot.writeStructEnd()
17772 
 
17773 
  def validate(self):
17774 
    return
17775 
 
17776 
 
17777 
  def __repr__(self):
17778 
    L = ['%s=%r' % (key, value)
17779 
      for key, value in self.__dict__.iteritems()]
17780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17781 
 
17782 
  def __eq__(self, other):
17783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17784 
 
17785 
  def __ne__(self, other):
17786 
    return not (self == other)
17787 
 
17788 
class addupdateVoucherForItem_result:
17789 
  """
17790 
  Attributes:
17791 
   - success
17792 
   - cex
17793 
  """
17794 
 
17795 
  thrift_spec = (
17796 
    (0, TType.BOOL, 'success', None, None, ), # 0
17797 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17798 
  )
17799 
 
17800 
  def __init__(self, success=None, cex=None,):
17801 
    self.success = success
17802 
    self.cex = cex
17803 
 
17804 
  def read(self, iprot):
17805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17807 
      return
17808 
    iprot.readStructBegin()
17809 
    while True:
17810 
      (fname, ftype, fid) = iprot.readFieldBegin()
17811 
      if ftype == TType.STOP:
17812 
        break
17813 
      if fid == 0:
17814 
        if ftype == TType.BOOL:
17815 
          self.success = iprot.readBool();
17816 
        else:
17817 
          iprot.skip(ftype)
17818 
      elif fid == 1:
17819 
        if ftype == TType.STRUCT:
17820 
          self.cex = CatalogServiceException()
17821 
          self.cex.read(iprot)
17822 
        else:
17823 
          iprot.skip(ftype)
17824 
      else:
17825 
        iprot.skip(ftype)
17826 
      iprot.readFieldEnd()
17827 
    iprot.readStructEnd()
17828 
 
17829 
  def write(self, oprot):
17830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17832 
      return
17833 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17834 
    if self.success is not None:
17835 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17836 
      oprot.writeBool(self.success)
17837 
      oprot.writeFieldEnd()
17838 
    if self.cex is not None:
17839 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17840 
      self.cex.write(oprot)
17841 
      oprot.writeFieldEnd()
17842 
    oprot.writeFieldStop()
17843 
    oprot.writeStructEnd()
17844 
 
17845 
  def validate(self):
17846 
    return
17847 
 
17848 
 
17849 
  def __repr__(self):
17850 
    L = ['%s=%r' % (key, value)
17851 
      for key, value in self.__dict__.iteritems()]
17852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17853 
 
17854 
  def __eq__(self, other):
17855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17856 
 
17857 
  def __ne__(self, other):
17858 
    return not (self == other)
17859 
 
17860 
class deleteVoucherForItem_args:
17861 
  """
17862 
  Attributes:
17863 
   - catalog_item_id
17864 
   - voucherType
17865 
  """
17866 
 
17867 
  thrift_spec = (
17868 
    None, # 0
17869 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17870 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17871 
  )
17872 
 
17873 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17874 
    self.catalog_item_id = catalog_item_id
17875 
    self.voucherType = voucherType
17876 
 
17877 
  def read(self, iprot):
17878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17880 
      return
17881 
    iprot.readStructBegin()
17882 
    while True:
17883 
      (fname, ftype, fid) = iprot.readFieldBegin()
17884 
      if ftype == TType.STOP:
17885 
        break
17886 
      if fid == 1:
17887 
        if ftype == TType.I64:
17888 
          self.catalog_item_id = iprot.readI64();
17889 
        else:
17890 
          iprot.skip(ftype)
17891 
      elif fid == 2:
17892 
        if ftype == TType.I64:
17893 
          self.voucherType = iprot.readI64();
17894 
        else:
17895 
          iprot.skip(ftype)
17896 
      else:
17897 
        iprot.skip(ftype)
17898 
      iprot.readFieldEnd()
17899 
    iprot.readStructEnd()
17900 
 
17901 
  def write(self, oprot):
17902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17904 
      return
17905 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17906 
    if self.catalog_item_id is not None:
17907 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17908 
      oprot.writeI64(self.catalog_item_id)
17909 
      oprot.writeFieldEnd()
17910 
    if self.voucherType is not None:
17911 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17912 
      oprot.writeI64(self.voucherType)
17913 
      oprot.writeFieldEnd()
17914 
    oprot.writeFieldStop()
17915 
    oprot.writeStructEnd()
17916 
 
17917 
  def validate(self):
17918 
    return
17919 
 
17920 
 
17921 
  def __repr__(self):
17922 
    L = ['%s=%r' % (key, value)
17923 
      for key, value in self.__dict__.iteritems()]
17924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17925 
 
17926 
  def __eq__(self, other):
17927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17928 
 
17929 
  def __ne__(self, other):
17930 
    return not (self == other)
17931 
 
17932 
class deleteVoucherForItem_result:
17933 
  """
17934 
  Attributes:
17935 
   - success
17936 
   - cex
17937 
  """
17938 
 
17939 
  thrift_spec = (
17940 
    (0, TType.BOOL, 'success', None, None, ), # 0
17941 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17942 
  )
17943 
 
17944 
  def __init__(self, success=None, cex=None,):
17945 
    self.success = success
17946 
    self.cex = cex
17947 
 
17948 
  def read(self, iprot):
17949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17951 
      return
17952 
    iprot.readStructBegin()
17953 
    while True:
17954 
      (fname, ftype, fid) = iprot.readFieldBegin()
17955 
      if ftype == TType.STOP:
17956 
        break
17957 
      if fid == 0:
17958 
        if ftype == TType.BOOL:
17959 
          self.success = iprot.readBool();
17960 
        else:
17961 
          iprot.skip(ftype)
17962 
      elif fid == 1:
17963 
        if ftype == TType.STRUCT:
17964 
          self.cex = CatalogServiceException()
17965 
          self.cex.read(iprot)
17966 
        else:
17967 
          iprot.skip(ftype)
17968 
      else:
17969 
        iprot.skip(ftype)
17970 
      iprot.readFieldEnd()
17971 
    iprot.readStructEnd()
17972 
 
17973 
  def write(self, oprot):
17974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17976 
      return
17977 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17978 
    if self.success is not None:
17979 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17980 
      oprot.writeBool(self.success)
17981 
      oprot.writeFieldEnd()
17982 
    if self.cex is not None:
17983 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17984 
      self.cex.write(oprot)
17985 
      oprot.writeFieldEnd()
17986 
    oprot.writeFieldStop()
17987 
    oprot.writeStructEnd()
17988 
 
17989 
  def validate(self):
17990 
    return
17991 
 
17992 
 
17993 
  def __repr__(self):
17994 
    L = ['%s=%r' % (key, value)
17995 
      for key, value in self.__dict__.iteritems()]
17996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17997 
 
17998 
  def __eq__(self, other):
17999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18000 
 
18001 
  def __ne__(self, other):
18002 
    return not (self == other)
18003 
 
18004 
class getVoucherAmount_args:
18005 
  """
18006 
  Attributes:
18007 
   - itemId
18008 
   - voucherType
18009 
  """
18010 
 
18011 
  thrift_spec = (
18012 
    None, # 0
18013 
    (1, TType.I64, 'itemId', None, None, ), # 1
18014 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18015 
  )
18016 
 
18017 
  def __init__(self, itemId=None, voucherType=None,):
18018 
    self.itemId = itemId
18019 
    self.voucherType = voucherType
18020 
 
18021 
  def read(self, iprot):
18022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18024 
      return
18025 
    iprot.readStructBegin()
18026 
    while True:
18027 
      (fname, ftype, fid) = iprot.readFieldBegin()
18028 
      if ftype == TType.STOP:
18029 
        break
18030 
      if fid == 1:
18031 
        if ftype == TType.I64:
18032 
          self.itemId = iprot.readI64();
18033 
        else:
18034 
          iprot.skip(ftype)
18035 
      elif fid == 2:
18036 
        if ftype == TType.I64:
18037 
          self.voucherType = iprot.readI64();
18038 
        else:
18039 
          iprot.skip(ftype)
18040 
      else:
18041 
        iprot.skip(ftype)
18042 
      iprot.readFieldEnd()
18043 
    iprot.readStructEnd()
18044 
 
18045 
  def write(self, oprot):
18046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18048 
      return
18049 
    oprot.writeStructBegin('getVoucherAmount_args')
18050 
    if self.itemId is not None:
18051 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18052 
      oprot.writeI64(self.itemId)
18053 
      oprot.writeFieldEnd()
18054 
    if self.voucherType is not None:
18055 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18056 
      oprot.writeI64(self.voucherType)
18057 
      oprot.writeFieldEnd()
18058 
    oprot.writeFieldStop()
18059 
    oprot.writeStructEnd()
18060 
 
18061 
  def validate(self):
18062 
    return
18063 
 
18064 
 
18065 
  def __repr__(self):
18066 
    L = ['%s=%r' % (key, value)
18067 
      for key, value in self.__dict__.iteritems()]
18068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18069 
 
18070 
  def __eq__(self, other):
18071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18072 
 
18073 
  def __ne__(self, other):
18074 
    return not (self == other)
18075 
 
18076 
class getVoucherAmount_result:
18077 
  """
18078 
  Attributes:
18079 
   - success
18080 
  """
18081 
 
18082 
  thrift_spec = (
18083 
    (0, TType.I64, 'success', None, None, ), # 0
18084 
  )
18085 
 
18086 
  def __init__(self, success=None,):
18087 
    self.success = success
18088 
 
18089 
  def read(self, iprot):
18090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18092 
      return
18093 
    iprot.readStructBegin()
18094 
    while True:
18095 
      (fname, ftype, fid) = iprot.readFieldBegin()
18096 
      if ftype == TType.STOP:
18097 
        break
18098 
      if fid == 0:
18099 
        if ftype == TType.I64:
18100 
          self.success = iprot.readI64();
18101 
        else:
18102 
          iprot.skip(ftype)
18103 
      else:
18104 
        iprot.skip(ftype)
18105 
      iprot.readFieldEnd()
18106 
    iprot.readStructEnd()
18107 
 
18108 
  def write(self, oprot):
18109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18111 
      return
18112 
    oprot.writeStructBegin('getVoucherAmount_result')
18113 
    if self.success is not None:
18114 
      oprot.writeFieldBegin('success', TType.I64, 0)
18115 
      oprot.writeI64(self.success)
18116 
      oprot.writeFieldEnd()
18117 
    oprot.writeFieldStop()
18118 
    oprot.writeStructEnd()
18119 
 
18120 
  def validate(self):
18121 
    return
18122 
 
18123 
 
18124 
  def __repr__(self):
18125 
    L = ['%s=%r' % (key, value)
18126 
      for key, value in self.__dict__.iteritems()]
18127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18128 
 
18129 
  def __eq__(self, other):
18130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18131 
 
18132 
  def __ne__(self, other):
18133 
    return not (self == other)
18134 
 
18135 
class getAllItemVouchers_args:
18136 
  """
18137 
  Attributes:
18138 
   - itemId
18139 
  """
18140 
 
18141 
  thrift_spec = (
18142 
    None, # 0
18143 
    (1, TType.I64, 'itemId', None, None, ), # 1
18144 
  )
18145 
 
18146 
  def __init__(self, itemId=None,):
18147 
    self.itemId = itemId
18148 
 
18149 
  def read(self, iprot):
18150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18152 
      return
18153 
    iprot.readStructBegin()
18154 
    while True:
18155 
      (fname, ftype, fid) = iprot.readFieldBegin()
18156 
      if ftype == TType.STOP:
18157 
        break
18158 
      if fid == 1:
18159 
        if ftype == TType.I64:
18160 
          self.itemId = iprot.readI64();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      else:
18164 
        iprot.skip(ftype)
18165 
      iprot.readFieldEnd()
18166 
    iprot.readStructEnd()
18167 
 
18168 
  def write(self, oprot):
18169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18171 
      return
18172 
    oprot.writeStructBegin('getAllItemVouchers_args')
18173 
    if self.itemId is not None:
18174 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18175 
      oprot.writeI64(self.itemId)
18176 
      oprot.writeFieldEnd()
18177 
    oprot.writeFieldStop()
18178 
    oprot.writeStructEnd()
18179 
 
18180 
  def validate(self):
18181 
    return
18182 
 
18183 
 
18184 
  def __repr__(self):
18185 
    L = ['%s=%r' % (key, value)
18186 
      for key, value in self.__dict__.iteritems()]
18187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18188 
 
18189 
  def __eq__(self, other):
18190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18191 
 
18192 
  def __ne__(self, other):
18193 
    return not (self == other)
18194 
 
18195 
class getAllItemVouchers_result:
18196 
  """
18197 
  Attributes:
18198 
   - success
18199 
  """
18200 
 
18201 
  thrift_spec = (
18202 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18203 
  )
18204 
 
18205 
  def __init__(self, success=None,):
18206 
    self.success = success
18207 
 
18208 
  def read(self, iprot):
18209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18211 
      return
18212 
    iprot.readStructBegin()
18213 
    while True:
18214 
      (fname, ftype, fid) = iprot.readFieldBegin()
18215 
      if ftype == TType.STOP:
18216 
        break
18217 
      if fid == 0:
18218 
        if ftype == TType.LIST:
18219 
          self.success = []
9155 kshitij.so 18220 
          (_etype363, _size360) = iprot.readListBegin()
18221 
          for _i364 in xrange(_size360):
18222 
            _elem365 = VoucherItemMapping()
18223 
            _elem365.read(iprot)
18224 
            self.success.append(_elem365)
5944 mandeep.dh 18225 
          iprot.readListEnd()
18226 
        else:
18227 
          iprot.skip(ftype)
18228 
      else:
18229 
        iprot.skip(ftype)
18230 
      iprot.readFieldEnd()
18231 
    iprot.readStructEnd()
18232 
 
18233 
  def write(self, oprot):
18234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18236 
      return
18237 
    oprot.writeStructBegin('getAllItemVouchers_result')
18238 
    if self.success is not None:
18239 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18240 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18241 
      for iter366 in self.success:
18242 
        iter366.write(oprot)
5944 mandeep.dh 18243 
      oprot.writeListEnd()
18244 
      oprot.writeFieldEnd()
18245 
    oprot.writeFieldStop()
18246 
    oprot.writeStructEnd()
18247 
 
18248 
  def validate(self):
18249 
    return
18250 
 
18251 
 
18252 
  def __repr__(self):
18253 
    L = ['%s=%r' % (key, value)
18254 
      for key, value in self.__dict__.iteritems()]
18255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18256 
 
18257 
  def __eq__(self, other):
18258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18259 
 
18260 
  def __ne__(self, other):
18261 
    return not (self == other)
18262 
 
18263 
class isValidCatalogItemId_args:
18264 
  """
18265 
  Attributes:
18266 
   - catalog_item_id
18267 
  """
18268 
 
18269 
  thrift_spec = (
18270 
    None, # 0
18271 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18272 
  )
18273 
 
18274 
  def __init__(self, catalog_item_id=None,):
18275 
    self.catalog_item_id = catalog_item_id
18276 
 
18277 
  def read(self, iprot):
18278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18280 
      return
18281 
    iprot.readStructBegin()
18282 
    while True:
18283 
      (fname, ftype, fid) = iprot.readFieldBegin()
18284 
      if ftype == TType.STOP:
18285 
        break
18286 
      if fid == 1:
18287 
        if ftype == TType.I64:
18288 
          self.catalog_item_id = iprot.readI64();
18289 
        else:
18290 
          iprot.skip(ftype)
18291 
      else:
18292 
        iprot.skip(ftype)
18293 
      iprot.readFieldEnd()
18294 
    iprot.readStructEnd()
18295 
 
18296 
  def write(self, oprot):
18297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18299 
      return
18300 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18301 
    if self.catalog_item_id is not None:
18302 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18303 
      oprot.writeI64(self.catalog_item_id)
18304 
      oprot.writeFieldEnd()
18305 
    oprot.writeFieldStop()
18306 
    oprot.writeStructEnd()
18307 
 
18308 
  def validate(self):
18309 
    return
18310 
 
18311 
 
18312 
  def __repr__(self):
18313 
    L = ['%s=%r' % (key, value)
18314 
      for key, value in self.__dict__.iteritems()]
18315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18316 
 
18317 
  def __eq__(self, other):
18318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18319 
 
18320 
  def __ne__(self, other):
18321 
    return not (self == other)
18322 
 
18323 
class isValidCatalogItemId_result:
18324 
  """
18325 
  Attributes:
18326 
   - success
18327 
  """
18328 
 
18329 
  thrift_spec = (
18330 
    (0, TType.BOOL, 'success', None, None, ), # 0
18331 
  )
18332 
 
18333 
  def __init__(self, success=None,):
18334 
    self.success = success
18335 
 
18336 
  def read(self, iprot):
18337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18339 
      return
18340 
    iprot.readStructBegin()
18341 
    while True:
18342 
      (fname, ftype, fid) = iprot.readFieldBegin()
18343 
      if ftype == TType.STOP:
18344 
        break
18345 
      if fid == 0:
18346 
        if ftype == TType.BOOL:
18347 
          self.success = iprot.readBool();
18348 
        else:
18349 
          iprot.skip(ftype)
18350 
      else:
18351 
        iprot.skip(ftype)
18352 
      iprot.readFieldEnd()
18353 
    iprot.readStructEnd()
18354 
 
18355 
  def write(self, oprot):
18356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18358 
      return
18359 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18360 
    if self.success is not None:
18361 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18362 
      oprot.writeBool(self.success)
18363 
      oprot.writeFieldEnd()
18364 
    oprot.writeFieldStop()
18365 
    oprot.writeStructEnd()
18366 
 
18367 
  def validate(self):
18368 
    return
18369 
 
18370 
 
18371 
  def __repr__(self):
18372 
    L = ['%s=%r' % (key, value)
18373 
      for key, value in self.__dict__.iteritems()]
18374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18375 
 
18376 
  def __eq__(self, other):
18377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18378 
 
18379 
  def __ne__(self, other):
18380 
    return not (self == other)
6039 amit.gupta 18381 
 
18382 
class getVatPercentageForItem_args:
18383 
  """
18384 
  Attributes:
18385 
   - itemId
7330 amit.gupta 18386 
   - stateId
6039 amit.gupta 18387 
   - price
18388 
  """
18389 
 
18390 
  thrift_spec = (
18391 
    None, # 0
18392 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18393 
    (2, TType.I64, 'stateId', None, None, ), # 2
18394 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18395 
  )
18396 
 
7330 amit.gupta 18397 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18398 
    self.itemId = itemId
7330 amit.gupta 18399 
    self.stateId = stateId
6039 amit.gupta 18400 
    self.price = price
18401 
 
18402 
  def read(self, iprot):
18403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18405 
      return
18406 
    iprot.readStructBegin()
18407 
    while True:
18408 
      (fname, ftype, fid) = iprot.readFieldBegin()
18409 
      if ftype == TType.STOP:
18410 
        break
18411 
      if fid == 1:
18412 
        if ftype == TType.I64:
18413 
          self.itemId = iprot.readI64();
18414 
        else:
18415 
          iprot.skip(ftype)
18416 
      elif fid == 2:
7330 amit.gupta 18417 
        if ftype == TType.I64:
18418 
          self.stateId = iprot.readI64();
18419 
        else:
18420 
          iprot.skip(ftype)
18421 
      elif fid == 3:
6039 amit.gupta 18422 
        if ftype == TType.DOUBLE:
18423 
          self.price = iprot.readDouble();
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      else:
18427 
        iprot.skip(ftype)
18428 
      iprot.readFieldEnd()
18429 
    iprot.readStructEnd()
18430 
 
18431 
  def write(self, oprot):
18432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18434 
      return
18435 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18436 
    if self.itemId is not None:
18437 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18438 
      oprot.writeI64(self.itemId)
18439 
      oprot.writeFieldEnd()
7330 amit.gupta 18440 
    if self.stateId is not None:
18441 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18442 
      oprot.writeI64(self.stateId)
18443 
      oprot.writeFieldEnd()
6039 amit.gupta 18444 
    if self.price is not None:
7330 amit.gupta 18445 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18446 
      oprot.writeDouble(self.price)
18447 
      oprot.writeFieldEnd()
18448 
    oprot.writeFieldStop()
18449 
    oprot.writeStructEnd()
18450 
 
18451 
  def validate(self):
18452 
    return
18453 
 
18454 
 
18455 
  def __repr__(self):
18456 
    L = ['%s=%r' % (key, value)
18457 
      for key, value in self.__dict__.iteritems()]
18458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18459 
 
18460 
  def __eq__(self, other):
18461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18462 
 
18463 
  def __ne__(self, other):
18464 
    return not (self == other)
18465 
 
18466 
class getVatPercentageForItem_result:
18467 
  """
18468 
  Attributes:
18469 
   - success
7340 amit.gupta 18470 
   - cex
6039 amit.gupta 18471 
  """
18472 
 
18473 
  thrift_spec = (
18474 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18475 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18476 
  )
18477 
 
7340 amit.gupta 18478 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18479 
    self.success = success
7340 amit.gupta 18480 
    self.cex = cex
6039 amit.gupta 18481 
 
18482 
  def read(self, iprot):
18483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18485 
      return
18486 
    iprot.readStructBegin()
18487 
    while True:
18488 
      (fname, ftype, fid) = iprot.readFieldBegin()
18489 
      if ftype == TType.STOP:
18490 
        break
18491 
      if fid == 0:
18492 
        if ftype == TType.DOUBLE:
18493 
          self.success = iprot.readDouble();
18494 
        else:
18495 
          iprot.skip(ftype)
7340 amit.gupta 18496 
      elif fid == 1:
18497 
        if ftype == TType.STRUCT:
18498 
          self.cex = CatalogServiceException()
18499 
          self.cex.read(iprot)
18500 
        else:
18501 
          iprot.skip(ftype)
6039 amit.gupta 18502 
      else:
18503 
        iprot.skip(ftype)
18504 
      iprot.readFieldEnd()
18505 
    iprot.readStructEnd()
18506 
 
18507 
  def write(self, oprot):
18508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18510 
      return
18511 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18512 
    if self.success is not None:
18513 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18514 
      oprot.writeDouble(self.success)
18515 
      oprot.writeFieldEnd()
7340 amit.gupta 18516 
    if self.cex is not None:
18517 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18518 
      self.cex.write(oprot)
18519 
      oprot.writeFieldEnd()
6039 amit.gupta 18520 
    oprot.writeFieldStop()
18521 
    oprot.writeStructEnd()
18522 
 
18523 
  def validate(self):
18524 
    return
18525 
 
18526 
 
18527 
  def __repr__(self):
18528 
    L = ['%s=%r' % (key, value)
18529 
      for key, value in self.__dict__.iteritems()]
18530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18531 
 
18532 
  def __eq__(self, other):
18533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18534 
 
18535 
  def __ne__(self, other):
18536 
    return not (self == other)
18537 
 
18538 
class getVatAmountForItem_args:
18539 
  """
18540 
  Attributes:
18541 
   - itemId
18542 
   - price
18543 
  """
18544 
 
18545 
  thrift_spec = (
18546 
    None, # 0
18547 
    (1, TType.I64, 'itemId', None, None, ), # 1
18548 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18549 
  )
18550 
 
18551 
  def __init__(self, itemId=None, price=None,):
18552 
    self.itemId = itemId
18553 
    self.price = price
18554 
 
18555 
  def read(self, iprot):
18556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18558 
      return
18559 
    iprot.readStructBegin()
18560 
    while True:
18561 
      (fname, ftype, fid) = iprot.readFieldBegin()
18562 
      if ftype == TType.STOP:
18563 
        break
18564 
      if fid == 1:
18565 
        if ftype == TType.I64:
18566 
          self.itemId = iprot.readI64();
18567 
        else:
18568 
          iprot.skip(ftype)
18569 
      elif fid == 2:
18570 
        if ftype == TType.DOUBLE:
18571 
          self.price = iprot.readDouble();
18572 
        else:
18573 
          iprot.skip(ftype)
18574 
      else:
18575 
        iprot.skip(ftype)
18576 
      iprot.readFieldEnd()
18577 
    iprot.readStructEnd()
18578 
 
18579 
  def write(self, oprot):
18580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18582 
      return
18583 
    oprot.writeStructBegin('getVatAmountForItem_args')
18584 
    if self.itemId is not None:
18585 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18586 
      oprot.writeI64(self.itemId)
18587 
      oprot.writeFieldEnd()
18588 
    if self.price is not None:
18589 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18590 
      oprot.writeDouble(self.price)
18591 
      oprot.writeFieldEnd()
18592 
    oprot.writeFieldStop()
18593 
    oprot.writeStructEnd()
18594 
 
18595 
  def validate(self):
18596 
    return
18597 
 
18598 
 
18599 
  def __repr__(self):
18600 
    L = ['%s=%r' % (key, value)
18601 
      for key, value in self.__dict__.iteritems()]
18602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18603 
 
18604 
  def __eq__(self, other):
18605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18606 
 
18607 
  def __ne__(self, other):
18608 
    return not (self == other)
18609 
 
18610 
class getVatAmountForItem_result:
18611 
  """
18612 
  Attributes:
18613 
   - success
18614 
  """
18615 
 
18616 
  thrift_spec = (
18617 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18618 
  )
18619 
 
18620 
  def __init__(self, success=None,):
18621 
    self.success = success
18622 
 
18623 
  def read(self, iprot):
18624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18626 
      return
18627 
    iprot.readStructBegin()
18628 
    while True:
18629 
      (fname, ftype, fid) = iprot.readFieldBegin()
18630 
      if ftype == TType.STOP:
18631 
        break
18632 
      if fid == 0:
18633 
        if ftype == TType.DOUBLE:
18634 
          self.success = iprot.readDouble();
18635 
        else:
18636 
          iprot.skip(ftype)
18637 
      else:
18638 
        iprot.skip(ftype)
18639 
      iprot.readFieldEnd()
18640 
    iprot.readStructEnd()
18641 
 
18642 
  def write(self, oprot):
18643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18645 
      return
18646 
    oprot.writeStructBegin('getVatAmountForItem_result')
18647 
    if self.success is not None:
18648 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18649 
      oprot.writeDouble(self.success)
18650 
      oprot.writeFieldEnd()
18651 
    oprot.writeFieldStop()
18652 
    oprot.writeStructEnd()
18653 
 
18654 
  def validate(self):
18655 
    return
18656 
 
18657 
 
18658 
  def __repr__(self):
18659 
    L = ['%s=%r' % (key, value)
18660 
      for key, value in self.__dict__.iteritems()]
18661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18662 
 
18663 
  def __eq__(self, other):
18664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18665 
 
18666 
  def __ne__(self, other):
18667 
    return not (self == other)
6531 vikram.rag 18668 
 
18669 
class getAllIgnoredInventoryUpdateItemsList_args:
18670 
  """
18671 
  Attributes:
18672 
   - offset
18673 
   - limit
18674 
  """
18675 
 
18676 
  thrift_spec = (
18677 
    None, # 0
18678 
    (1, TType.I32, 'offset', None, None, ), # 1
18679 
    (2, TType.I32, 'limit', None, None, ), # 2
18680 
  )
18681 
 
18682 
  def __init__(self, offset=None, limit=None,):
18683 
    self.offset = offset
18684 
    self.limit = limit
18685 
 
18686 
  def read(self, iprot):
18687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18689 
      return
18690 
    iprot.readStructBegin()
18691 
    while True:
18692 
      (fname, ftype, fid) = iprot.readFieldBegin()
18693 
      if ftype == TType.STOP:
18694 
        break
18695 
      if fid == 1:
18696 
        if ftype == TType.I32:
18697 
          self.offset = iprot.readI32();
18698 
        else:
18699 
          iprot.skip(ftype)
18700 
      elif fid == 2:
18701 
        if ftype == TType.I32:
18702 
          self.limit = iprot.readI32();
18703 
        else:
18704 
          iprot.skip(ftype)
18705 
      else:
18706 
        iprot.skip(ftype)
18707 
      iprot.readFieldEnd()
18708 
    iprot.readStructEnd()
18709 
 
18710 
  def write(self, oprot):
18711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18713 
      return
18714 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18715 
    if self.offset is not None:
18716 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18717 
      oprot.writeI32(self.offset)
18718 
      oprot.writeFieldEnd()
18719 
    if self.limit is not None:
18720 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18721 
      oprot.writeI32(self.limit)
18722 
      oprot.writeFieldEnd()
18723 
    oprot.writeFieldStop()
18724 
    oprot.writeStructEnd()
18725 
 
18726 
  def validate(self):
18727 
    return
18728 
 
18729 
 
18730 
  def __repr__(self):
18731 
    L = ['%s=%r' % (key, value)
18732 
      for key, value in self.__dict__.iteritems()]
18733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18734 
 
18735 
  def __eq__(self, other):
18736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18737 
 
18738 
  def __ne__(self, other):
18739 
    return not (self == other)
18740 
 
18741 
class getAllIgnoredInventoryUpdateItemsList_result:
18742 
  """
18743 
  Attributes:
18744 
   - success
18745 
  """
18746 
 
18747 
  thrift_spec = (
18748 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18749 
  )
18750 
 
18751 
  def __init__(self, success=None,):
18752 
    self.success = success
18753 
 
18754 
  def read(self, iprot):
18755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18757 
      return
18758 
    iprot.readStructBegin()
18759 
    while True:
18760 
      (fname, ftype, fid) = iprot.readFieldBegin()
18761 
      if ftype == TType.STOP:
18762 
        break
18763 
      if fid == 0:
18764 
        if ftype == TType.LIST:
18765 
          self.success = []
9155 kshitij.so 18766 
          (_etype370, _size367) = iprot.readListBegin()
18767 
          for _i371 in xrange(_size367):
18768 
            _elem372 = Item()
18769 
            _elem372.read(iprot)
18770 
            self.success.append(_elem372)
6531 vikram.rag 18771 
          iprot.readListEnd()
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      else:
18775 
        iprot.skip(ftype)
18776 
      iprot.readFieldEnd()
18777 
    iprot.readStructEnd()
18778 
 
18779 
  def write(self, oprot):
18780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18782 
      return
18783 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18784 
    if self.success is not None:
18785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18787 
      for iter373 in self.success:
18788 
        iter373.write(oprot)
6531 vikram.rag 18789 
      oprot.writeListEnd()
18790 
      oprot.writeFieldEnd()
18791 
    oprot.writeFieldStop()
18792 
    oprot.writeStructEnd()
18793 
 
18794 
  def validate(self):
18795 
    return
18796 
 
18797 
 
18798 
  def __repr__(self):
18799 
    L = ['%s=%r' % (key, value)
18800 
      for key, value in self.__dict__.iteritems()]
18801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18802 
 
18803 
  def __eq__(self, other):
18804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18805 
 
18806 
  def __ne__(self, other):
18807 
    return not (self == other)
6805 anupam.sin 18808 
 
6821 amar.kumar 18809 
class getAllAliveItems_args:
18810 
 
18811 
  thrift_spec = (
18812 
  )
18813 
 
18814 
  def read(self, iprot):
18815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18817 
      return
18818 
    iprot.readStructBegin()
18819 
    while True:
18820 
      (fname, ftype, fid) = iprot.readFieldBegin()
18821 
      if ftype == TType.STOP:
18822 
        break
18823 
      else:
18824 
        iprot.skip(ftype)
18825 
      iprot.readFieldEnd()
18826 
    iprot.readStructEnd()
18827 
 
18828 
  def write(self, oprot):
18829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18831 
      return
18832 
    oprot.writeStructBegin('getAllAliveItems_args')
18833 
    oprot.writeFieldStop()
18834 
    oprot.writeStructEnd()
18835 
 
18836 
  def validate(self):
18837 
    return
18838 
 
18839 
 
18840 
  def __repr__(self):
18841 
    L = ['%s=%r' % (key, value)
18842 
      for key, value in self.__dict__.iteritems()]
18843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18844 
 
18845 
  def __eq__(self, other):
18846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18847 
 
18848 
  def __ne__(self, other):
18849 
    return not (self == other)
18850 
 
18851 
class getAllAliveItems_result:
18852 
  """
18853 
  Attributes:
18854 
   - success
18855 
  """
18856 
 
18857 
  thrift_spec = (
18858 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18859 
  )
18860 
 
18861 
  def __init__(self, success=None,):
18862 
    self.success = success
18863 
 
18864 
  def read(self, iprot):
18865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18867 
      return
18868 
    iprot.readStructBegin()
18869 
    while True:
18870 
      (fname, ftype, fid) = iprot.readFieldBegin()
18871 
      if ftype == TType.STOP:
18872 
        break
18873 
      if fid == 0:
18874 
        if ftype == TType.LIST:
18875 
          self.success = []
9155 kshitij.so 18876 
          (_etype377, _size374) = iprot.readListBegin()
18877 
          for _i378 in xrange(_size374):
18878 
            _elem379 = Item()
18879 
            _elem379.read(iprot)
18880 
            self.success.append(_elem379)
6821 amar.kumar 18881 
          iprot.readListEnd()
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      else:
18885 
        iprot.skip(ftype)
18886 
      iprot.readFieldEnd()
18887 
    iprot.readStructEnd()
18888 
 
18889 
  def write(self, oprot):
18890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18892 
      return
18893 
    oprot.writeStructBegin('getAllAliveItems_result')
18894 
    if self.success is not None:
18895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18897 
      for iter380 in self.success:
18898 
        iter380.write(oprot)
6821 amar.kumar 18899 
      oprot.writeListEnd()
18900 
      oprot.writeFieldEnd()
18901 
    oprot.writeFieldStop()
18902 
    oprot.writeStructEnd()
18903 
 
18904 
  def validate(self):
18905 
    return
18906 
 
18907 
 
18908 
  def __repr__(self):
18909 
    L = ['%s=%r' % (key, value)
18910 
      for key, value in self.__dict__.iteritems()]
18911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18912 
 
18913 
  def __eq__(self, other):
18914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18915 
 
18916 
  def __ne__(self, other):
18917 
    return not (self == other)
18918 
 
6805 anupam.sin 18919 
class getInsuranceAmount_args:
18920 
  """
18921 
  Attributes:
18922 
   - itemId
6921 anupam.sin 18923 
   - price
6805 anupam.sin 18924 
   - insurerId
18925 
   - quantity
18926 
  """
18927 
 
18928 
  thrift_spec = (
18929 
    None, # 0
18930 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18931 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18932 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18933 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18934 
  )
18935 
 
6921 anupam.sin 18936 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18937 
    self.itemId = itemId
6921 anupam.sin 18938 
    self.price = price
6805 anupam.sin 18939 
    self.insurerId = insurerId
18940 
    self.quantity = quantity
18941 
 
18942 
  def read(self, iprot):
18943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18945 
      return
18946 
    iprot.readStructBegin()
18947 
    while True:
18948 
      (fname, ftype, fid) = iprot.readFieldBegin()
18949 
      if ftype == TType.STOP:
18950 
        break
18951 
      if fid == 1:
18952 
        if ftype == TType.I64:
18953 
          self.itemId = iprot.readI64();
18954 
        else:
18955 
          iprot.skip(ftype)
18956 
      elif fid == 2:
6921 anupam.sin 18957 
        if ftype == TType.DOUBLE:
18958 
          self.price = iprot.readDouble();
18959 
        else:
18960 
          iprot.skip(ftype)
18961 
      elif fid == 3:
6805 anupam.sin 18962 
        if ftype == TType.I64:
18963 
          self.insurerId = iprot.readI64();
18964 
        else:
18965 
          iprot.skip(ftype)
6921 anupam.sin 18966 
      elif fid == 4:
6805 anupam.sin 18967 
        if ftype == TType.I64:
18968 
          self.quantity = iprot.readI64();
18969 
        else:
18970 
          iprot.skip(ftype)
18971 
      else:
18972 
        iprot.skip(ftype)
18973 
      iprot.readFieldEnd()
18974 
    iprot.readStructEnd()
18975 
 
18976 
  def write(self, oprot):
18977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18979 
      return
18980 
    oprot.writeStructBegin('getInsuranceAmount_args')
18981 
    if self.itemId is not None:
18982 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18983 
      oprot.writeI64(self.itemId)
18984 
      oprot.writeFieldEnd()
6921 anupam.sin 18985 
    if self.price is not None:
18986 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18987 
      oprot.writeDouble(self.price)
18988 
      oprot.writeFieldEnd()
6805 anupam.sin 18989 
    if self.insurerId is not None:
6921 anupam.sin 18990 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18991 
      oprot.writeI64(self.insurerId)
18992 
      oprot.writeFieldEnd()
18993 
    if self.quantity is not None:
6921 anupam.sin 18994 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18995 
      oprot.writeI64(self.quantity)
18996 
      oprot.writeFieldEnd()
18997 
    oprot.writeFieldStop()
18998 
    oprot.writeStructEnd()
18999 
 
19000 
  def validate(self):
19001 
    return
19002 
 
19003 
 
19004 
  def __repr__(self):
19005 
    L = ['%s=%r' % (key, value)
19006 
      for key, value in self.__dict__.iteritems()]
19007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19008 
 
19009 
  def __eq__(self, other):
19010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19011 
 
19012 
  def __ne__(self, other):
19013 
    return not (self == other)
19014 
 
19015 
class getInsuranceAmount_result:
19016 
  """
19017 
  Attributes:
19018 
   - success
19019 
  """
19020 
 
19021 
  thrift_spec = (
19022 
    (0, TType.I64, 'success', None, None, ), # 0
19023 
  )
19024 
 
19025 
  def __init__(self, success=None,):
19026 
    self.success = success
19027 
 
19028 
  def read(self, iprot):
19029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19031 
      return
19032 
    iprot.readStructBegin()
19033 
    while True:
19034 
      (fname, ftype, fid) = iprot.readFieldBegin()
19035 
      if ftype == TType.STOP:
19036 
        break
19037 
      if fid == 0:
19038 
        if ftype == TType.I64:
19039 
          self.success = iprot.readI64();
19040 
        else:
19041 
          iprot.skip(ftype)
19042 
      else:
19043 
        iprot.skip(ftype)
19044 
      iprot.readFieldEnd()
19045 
    iprot.readStructEnd()
19046 
 
19047 
  def write(self, oprot):
19048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19050 
      return
19051 
    oprot.writeStructBegin('getInsuranceAmount_result')
19052 
    if self.success is not None:
19053 
      oprot.writeFieldBegin('success', TType.I64, 0)
19054 
      oprot.writeI64(self.success)
19055 
      oprot.writeFieldEnd()
19056 
    oprot.writeFieldStop()
19057 
    oprot.writeStructEnd()
19058 
 
19059 
  def validate(self):
19060 
    return
19061 
 
19062 
 
19063 
  def __repr__(self):
19064 
    L = ['%s=%r' % (key, value)
19065 
      for key, value in self.__dict__.iteritems()]
19066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19067 
 
19068 
  def __eq__(self, other):
19069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19070 
 
19071 
  def __ne__(self, other):
19072 
    return not (self == other)
19073 
 
19074 
class getInsurer_args:
19075 
  """
19076 
  Attributes:
19077 
   - insurerId
19078 
  """
19079 
 
19080 
  thrift_spec = (
19081 
    None, # 0
19082 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19083 
  )
19084 
 
19085 
  def __init__(self, insurerId=None,):
19086 
    self.insurerId = insurerId
19087 
 
19088 
  def read(self, iprot):
19089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19091 
      return
19092 
    iprot.readStructBegin()
19093 
    while True:
19094 
      (fname, ftype, fid) = iprot.readFieldBegin()
19095 
      if ftype == TType.STOP:
19096 
        break
19097 
      if fid == 1:
19098 
        if ftype == TType.I64:
19099 
          self.insurerId = iprot.readI64();
19100 
        else:
19101 
          iprot.skip(ftype)
19102 
      else:
19103 
        iprot.skip(ftype)
19104 
      iprot.readFieldEnd()
19105 
    iprot.readStructEnd()
19106 
 
19107 
  def write(self, oprot):
19108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19110 
      return
19111 
    oprot.writeStructBegin('getInsurer_args')
19112 
    if self.insurerId is not None:
19113 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19114 
      oprot.writeI64(self.insurerId)
19115 
      oprot.writeFieldEnd()
19116 
    oprot.writeFieldStop()
19117 
    oprot.writeStructEnd()
19118 
 
19119 
  def validate(self):
19120 
    return
19121 
 
19122 
 
19123 
  def __repr__(self):
19124 
    L = ['%s=%r' % (key, value)
19125 
      for key, value in self.__dict__.iteritems()]
19126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19127 
 
19128 
  def __eq__(self, other):
19129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19130 
 
19131 
  def __ne__(self, other):
19132 
    return not (self == other)
19133 
 
19134 
class getInsurer_result:
19135 
  """
19136 
  Attributes:
19137 
   - success
19138 
  """
19139 
 
19140 
  thrift_spec = (
19141 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19142 
  )
19143 
 
19144 
  def __init__(self, success=None,):
19145 
    self.success = success
19146 
 
19147 
  def read(self, iprot):
19148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19150 
      return
19151 
    iprot.readStructBegin()
19152 
    while True:
19153 
      (fname, ftype, fid) = iprot.readFieldBegin()
19154 
      if ftype == TType.STOP:
19155 
        break
19156 
      if fid == 0:
19157 
        if ftype == TType.STRUCT:
19158 
          self.success = Insurer()
19159 
          self.success.read(iprot)
19160 
        else:
19161 
          iprot.skip(ftype)
19162 
      else:
19163 
        iprot.skip(ftype)
19164 
      iprot.readFieldEnd()
19165 
    iprot.readStructEnd()
19166 
 
19167 
  def write(self, oprot):
19168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19170 
      return
19171 
    oprot.writeStructBegin('getInsurer_result')
19172 
    if self.success is not None:
19173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19174 
      self.success.write(oprot)
19175 
      oprot.writeFieldEnd()
19176 
    oprot.writeFieldStop()
19177 
    oprot.writeStructEnd()
19178 
 
19179 
  def validate(self):
19180 
    return
19181 
 
19182 
 
19183 
  def __repr__(self):
19184 
    L = ['%s=%r' % (key, value)
19185 
      for key, value in self.__dict__.iteritems()]
19186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19187 
 
19188 
  def __eq__(self, other):
19189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19190 
 
19191 
  def __ne__(self, other):
19192 
    return not (self == other)
6838 vikram.rag 19193 
 
19194 
class getAllInsurers_args:
19195 
 
19196 
  thrift_spec = (
19197 
  )
19198 
 
19199 
  def read(self, iprot):
19200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19202 
      return
19203 
    iprot.readStructBegin()
19204 
    while True:
19205 
      (fname, ftype, fid) = iprot.readFieldBegin()
19206 
      if ftype == TType.STOP:
19207 
        break
19208 
      else:
19209 
        iprot.skip(ftype)
19210 
      iprot.readFieldEnd()
19211 
    iprot.readStructEnd()
19212 
 
19213 
  def write(self, oprot):
19214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19216 
      return
19217 
    oprot.writeStructBegin('getAllInsurers_args')
19218 
    oprot.writeFieldStop()
19219 
    oprot.writeStructEnd()
19220 
 
19221 
  def validate(self):
19222 
    return
19223 
 
19224 
 
19225 
  def __repr__(self):
19226 
    L = ['%s=%r' % (key, value)
19227 
      for key, value in self.__dict__.iteritems()]
19228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19229 
 
19230 
  def __eq__(self, other):
19231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19232 
 
19233 
  def __ne__(self, other):
19234 
    return not (self == other)
19235 
 
19236 
class getAllInsurers_result:
19237 
  """
19238 
  Attributes:
19239 
   - success
19240 
  """
19241 
 
19242 
  thrift_spec = (
19243 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19244 
  )
19245 
 
19246 
  def __init__(self, success=None,):
19247 
    self.success = success
19248 
 
19249 
  def read(self, iprot):
19250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19252 
      return
19253 
    iprot.readStructBegin()
19254 
    while True:
19255 
      (fname, ftype, fid) = iprot.readFieldBegin()
19256 
      if ftype == TType.STOP:
19257 
        break
19258 
      if fid == 0:
19259 
        if ftype == TType.LIST:
19260 
          self.success = []
9155 kshitij.so 19261 
          (_etype384, _size381) = iprot.readListBegin()
19262 
          for _i385 in xrange(_size381):
19263 
            _elem386 = Insurer()
19264 
            _elem386.read(iprot)
19265 
            self.success.append(_elem386)
6838 vikram.rag 19266 
          iprot.readListEnd()
19267 
        else:
19268 
          iprot.skip(ftype)
19269 
      else:
19270 
        iprot.skip(ftype)
19271 
      iprot.readFieldEnd()
19272 
    iprot.readStructEnd()
19273 
 
19274 
  def write(self, oprot):
19275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19277 
      return
19278 
    oprot.writeStructBegin('getAllInsurers_result')
19279 
    if self.success is not None:
19280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19282 
      for iter387 in self.success:
19283 
        iter387.write(oprot)
6838 vikram.rag 19284 
      oprot.writeListEnd()
19285 
      oprot.writeFieldEnd()
19286 
    oprot.writeFieldStop()
19287 
    oprot.writeStructEnd()
19288 
 
19289 
  def validate(self):
19290 
    return
19291 
 
19292 
 
19293 
  def __repr__(self):
19294 
    L = ['%s=%r' % (key, value)
19295 
      for key, value in self.__dict__.iteritems()]
19296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19297 
 
19298 
  def __eq__(self, other):
19299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19300 
 
19301 
  def __ne__(self, other):
19302 
    return not (self == other)
6962 rajveer 19303 
 
19304 
class updateInsuranceDeclaredAmount_args:
19305 
  """
19306 
  Attributes:
19307 
   - insurerId
19308 
   - amount
19309 
  """
19310 
 
19311 
  thrift_spec = (
19312 
    None, # 0
19313 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19314 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19315 
  )
19316 
 
19317 
  def __init__(self, insurerId=None, amount=None,):
19318 
    self.insurerId = insurerId
19319 
    self.amount = amount
19320 
 
19321 
  def read(self, iprot):
19322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19324 
      return
19325 
    iprot.readStructBegin()
19326 
    while True:
19327 
      (fname, ftype, fid) = iprot.readFieldBegin()
19328 
      if ftype == TType.STOP:
19329 
        break
19330 
      if fid == 1:
19331 
        if ftype == TType.I64:
19332 
          self.insurerId = iprot.readI64();
19333 
        else:
19334 
          iprot.skip(ftype)
19335 
      elif fid == 2:
19336 
        if ftype == TType.DOUBLE:
19337 
          self.amount = iprot.readDouble();
19338 
        else:
19339 
          iprot.skip(ftype)
19340 
      else:
19341 
        iprot.skip(ftype)
19342 
      iprot.readFieldEnd()
19343 
    iprot.readStructEnd()
19344 
 
19345 
  def write(self, oprot):
19346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19348 
      return
19349 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19350 
    if self.insurerId is not None:
19351 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19352 
      oprot.writeI64(self.insurerId)
19353 
      oprot.writeFieldEnd()
19354 
    if self.amount is not None:
19355 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19356 
      oprot.writeDouble(self.amount)
19357 
      oprot.writeFieldEnd()
19358 
    oprot.writeFieldStop()
19359 
    oprot.writeStructEnd()
19360 
 
19361 
  def validate(self):
19362 
    return
19363 
 
19364 
 
19365 
  def __repr__(self):
19366 
    L = ['%s=%r' % (key, value)
19367 
      for key, value in self.__dict__.iteritems()]
19368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19369 
 
19370 
  def __eq__(self, other):
19371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19372 
 
19373 
  def __ne__(self, other):
19374 
    return not (self == other)
19375 
 
19376 
class updateInsuranceDeclaredAmount_result:
19377 
 
19378 
  thrift_spec = (
19379 
  )
19380 
 
19381 
  def read(self, iprot):
19382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19384 
      return
19385 
    iprot.readStructBegin()
19386 
    while True:
19387 
      (fname, ftype, fid) = iprot.readFieldBegin()
19388 
      if ftype == TType.STOP:
19389 
        break
19390 
      else:
19391 
        iprot.skip(ftype)
19392 
      iprot.readFieldEnd()
19393 
    iprot.readStructEnd()
19394 
 
19395 
  def write(self, oprot):
19396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19398 
      return
19399 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19400 
    oprot.writeFieldStop()
19401 
    oprot.writeStructEnd()
19402 
 
19403 
  def validate(self):
19404 
    return
19405 
 
19406 
 
19407 
  def __repr__(self):
19408 
    L = ['%s=%r' % (key, value)
19409 
      for key, value in self.__dict__.iteritems()]
19410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19411 
 
19412 
  def __eq__(self, other):
19413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19414 
 
19415 
  def __ne__(self, other):
19416 
    return not (self == other)
7190 amar.kumar 19417 
 
19418 
class getFreebieForItem_args:
19419 
  """
19420 
  Attributes:
19421 
   - itemId
19422 
  """
19423 
 
19424 
  thrift_spec = (
19425 
    None, # 0
19426 
    (1, TType.I64, 'itemId', None, None, ), # 1
19427 
  )
19428 
 
19429 
  def __init__(self, itemId=None,):
19430 
    self.itemId = itemId
19431 
 
19432 
  def read(self, iprot):
19433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19435 
      return
19436 
    iprot.readStructBegin()
19437 
    while True:
19438 
      (fname, ftype, fid) = iprot.readFieldBegin()
19439 
      if ftype == TType.STOP:
19440 
        break
19441 
      if fid == 1:
19442 
        if ftype == TType.I64:
19443 
          self.itemId = iprot.readI64();
19444 
        else:
19445 
          iprot.skip(ftype)
19446 
      else:
19447 
        iprot.skip(ftype)
19448 
      iprot.readFieldEnd()
19449 
    iprot.readStructEnd()
19450 
 
19451 
  def write(self, oprot):
19452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19454 
      return
19455 
    oprot.writeStructBegin('getFreebieForItem_args')
19456 
    if self.itemId is not None:
19457 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19458 
      oprot.writeI64(self.itemId)
19459 
      oprot.writeFieldEnd()
19460 
    oprot.writeFieldStop()
19461 
    oprot.writeStructEnd()
19462 
 
19463 
  def validate(self):
19464 
    return
19465 
 
19466 
 
19467 
  def __repr__(self):
19468 
    L = ['%s=%r' % (key, value)
19469 
      for key, value in self.__dict__.iteritems()]
19470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19471 
 
19472 
  def __eq__(self, other):
19473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19474 
 
19475 
  def __ne__(self, other):
19476 
    return not (self == other)
19477 
 
19478 
class getFreebieForItem_result:
19479 
  """
19480 
  Attributes:
19481 
   - success
19482 
  """
19483 
 
19484 
  thrift_spec = (
19485 
    (0, TType.I64, 'success', None, None, ), # 0
19486 
  )
19487 
 
19488 
  def __init__(self, success=None,):
19489 
    self.success = success
19490 
 
19491 
  def read(self, iprot):
19492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19494 
      return
19495 
    iprot.readStructBegin()
19496 
    while True:
19497 
      (fname, ftype, fid) = iprot.readFieldBegin()
19498 
      if ftype == TType.STOP:
19499 
        break
19500 
      if fid == 0:
19501 
        if ftype == TType.I64:
19502 
          self.success = iprot.readI64();
19503 
        else:
19504 
          iprot.skip(ftype)
19505 
      else:
19506 
        iprot.skip(ftype)
19507 
      iprot.readFieldEnd()
19508 
    iprot.readStructEnd()
19509 
 
19510 
  def write(self, oprot):
19511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19513 
      return
19514 
    oprot.writeStructBegin('getFreebieForItem_result')
19515 
    if self.success is not None:
19516 
      oprot.writeFieldBegin('success', TType.I64, 0)
19517 
      oprot.writeI64(self.success)
19518 
      oprot.writeFieldEnd()
19519 
    oprot.writeFieldStop()
19520 
    oprot.writeStructEnd()
19521 
 
19522 
  def validate(self):
19523 
    return
19524 
 
19525 
 
19526 
  def __repr__(self):
19527 
    L = ['%s=%r' % (key, value)
19528 
      for key, value in self.__dict__.iteritems()]
19529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19530 
 
19531 
  def __eq__(self, other):
19532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19533 
 
19534 
  def __ne__(self, other):
19535 
    return not (self == other)
19536 
 
19537 
class addOrUpdateFreebieForItem_args:
19538 
  """
19539 
  Attributes:
19540 
   - freebieItem
19541 
  """
19542 
 
19543 
  thrift_spec = (
19544 
    None, # 0
19545 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19546 
  )
19547 
 
19548 
  def __init__(self, freebieItem=None,):
19549 
    self.freebieItem = freebieItem
19550 
 
19551 
  def read(self, iprot):
19552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19554 
      return
19555 
    iprot.readStructBegin()
19556 
    while True:
19557 
      (fname, ftype, fid) = iprot.readFieldBegin()
19558 
      if ftype == TType.STOP:
19559 
        break
19560 
      if fid == 1:
19561 
        if ftype == TType.STRUCT:
19562 
          self.freebieItem = FreebieItem()
19563 
          self.freebieItem.read(iprot)
19564 
        else:
19565 
          iprot.skip(ftype)
19566 
      else:
19567 
        iprot.skip(ftype)
19568 
      iprot.readFieldEnd()
19569 
    iprot.readStructEnd()
19570 
 
19571 
  def write(self, oprot):
19572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19574 
      return
19575 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19576 
    if self.freebieItem is not None:
19577 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19578 
      self.freebieItem.write(oprot)
19579 
      oprot.writeFieldEnd()
19580 
    oprot.writeFieldStop()
19581 
    oprot.writeStructEnd()
19582 
 
19583 
  def validate(self):
19584 
    return
19585 
 
19586 
 
19587 
  def __repr__(self):
19588 
    L = ['%s=%r' % (key, value)
19589 
      for key, value in self.__dict__.iteritems()]
19590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19591 
 
19592 
  def __eq__(self, other):
19593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19594 
 
19595 
  def __ne__(self, other):
19596 
    return not (self == other)
19597 
 
19598 
class addOrUpdateFreebieForItem_result:
19599 
 
19600 
  thrift_spec = (
19601 
  )
19602 
 
19603 
  def read(self, iprot):
19604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19606 
      return
19607 
    iprot.readStructBegin()
19608 
    while True:
19609 
      (fname, ftype, fid) = iprot.readFieldBegin()
19610 
      if ftype == TType.STOP:
19611 
        break
19612 
      else:
19613 
        iprot.skip(ftype)
19614 
      iprot.readFieldEnd()
19615 
    iprot.readStructEnd()
19616 
 
19617 
  def write(self, oprot):
19618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19620 
      return
19621 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19622 
    oprot.writeFieldStop()
19623 
    oprot.writeStructEnd()
19624 
 
19625 
  def validate(self):
19626 
    return
19627 
 
19628 
 
19629 
  def __repr__(self):
19630 
    L = ['%s=%r' % (key, value)
19631 
      for key, value in self.__dict__.iteritems()]
19632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19633 
 
19634 
  def __eq__(self, other):
19635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19636 
 
19637 
  def __ne__(self, other):
19638 
    return not (self == other)
7256 rajveer 19639 
 
7272 amit.gupta 19640 
class addOrUpdateBrandInfo_args:
19641 
  """
19642 
  Attributes:
19643 
   - brandInfo
19644 
  """
19645 
 
19646 
  thrift_spec = (
19647 
    None, # 0
19648 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19649 
  )
19650 
 
19651 
  def __init__(self, brandInfo=None,):
19652 
    self.brandInfo = brandInfo
19653 
 
19654 
  def read(self, iprot):
19655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19657 
      return
19658 
    iprot.readStructBegin()
19659 
    while True:
19660 
      (fname, ftype, fid) = iprot.readFieldBegin()
19661 
      if ftype == TType.STOP:
19662 
        break
19663 
      if fid == 1:
19664 
        if ftype == TType.STRUCT:
19665 
          self.brandInfo = BrandInfo()
19666 
          self.brandInfo.read(iprot)
19667 
        else:
19668 
          iprot.skip(ftype)
19669 
      else:
19670 
        iprot.skip(ftype)
19671 
      iprot.readFieldEnd()
19672 
    iprot.readStructEnd()
19673 
 
19674 
  def write(self, oprot):
19675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19677 
      return
19678 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19679 
    if self.brandInfo is not None:
19680 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19681 
      self.brandInfo.write(oprot)
19682 
      oprot.writeFieldEnd()
19683 
    oprot.writeFieldStop()
19684 
    oprot.writeStructEnd()
19685 
 
19686 
  def validate(self):
19687 
    return
19688 
 
19689 
 
19690 
  def __repr__(self):
19691 
    L = ['%s=%r' % (key, value)
19692 
      for key, value in self.__dict__.iteritems()]
19693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19694 
 
19695 
  def __eq__(self, other):
19696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19697 
 
19698 
  def __ne__(self, other):
19699 
    return not (self == other)
19700 
 
19701 
class addOrUpdateBrandInfo_result:
19702 
 
19703 
  thrift_spec = (
19704 
  )
19705 
 
19706 
  def read(self, iprot):
19707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19709 
      return
19710 
    iprot.readStructBegin()
19711 
    while True:
19712 
      (fname, ftype, fid) = iprot.readFieldBegin()
19713 
      if ftype == TType.STOP:
19714 
        break
19715 
      else:
19716 
        iprot.skip(ftype)
19717 
      iprot.readFieldEnd()
19718 
    iprot.readStructEnd()
19719 
 
19720 
  def write(self, oprot):
19721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19723 
      return
19724 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19725 
    oprot.writeFieldStop()
19726 
    oprot.writeStructEnd()
19727 
 
19728 
  def validate(self):
19729 
    return
19730 
 
19731 
 
19732 
  def __repr__(self):
19733 
    L = ['%s=%r' % (key, value)
19734 
      for key, value in self.__dict__.iteritems()]
19735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19736 
 
19737 
  def __eq__(self, other):
19738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19739 
 
19740 
  def __ne__(self, other):
19741 
    return not (self == other)
19742 
 
19743 
class getBrandInfo_args:
19744 
 
19745 
  thrift_spec = (
19746 
  )
19747 
 
19748 
  def read(self, iprot):
19749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19751 
      return
19752 
    iprot.readStructBegin()
19753 
    while True:
19754 
      (fname, ftype, fid) = iprot.readFieldBegin()
19755 
      if ftype == TType.STOP:
19756 
        break
19757 
      else:
19758 
        iprot.skip(ftype)
19759 
      iprot.readFieldEnd()
19760 
    iprot.readStructEnd()
19761 
 
19762 
  def write(self, oprot):
19763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19765 
      return
19766 
    oprot.writeStructBegin('getBrandInfo_args')
19767 
    oprot.writeFieldStop()
19768 
    oprot.writeStructEnd()
19769 
 
19770 
  def validate(self):
19771 
    return
19772 
 
19773 
 
19774 
  def __repr__(self):
19775 
    L = ['%s=%r' % (key, value)
19776 
      for key, value in self.__dict__.iteritems()]
19777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19778 
 
19779 
  def __eq__(self, other):
19780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19781 
 
19782 
  def __ne__(self, other):
19783 
    return not (self == other)
19784 
 
19785 
class getBrandInfo_result:
19786 
  """
19787 
  Attributes:
19788 
   - success
19789 
  """
19790 
 
19791 
  thrift_spec = (
19792 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19793 
  )
19794 
 
19795 
  def __init__(self, success=None,):
19796 
    self.success = success
19797 
 
19798 
  def read(self, iprot):
19799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19801 
      return
19802 
    iprot.readStructBegin()
19803 
    while True:
19804 
      (fname, ftype, fid) = iprot.readFieldBegin()
19805 
      if ftype == TType.STOP:
19806 
        break
19807 
      if fid == 0:
19808 
        if ftype == TType.MAP:
19809 
          self.success = {}
9155 kshitij.so 19810 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19811 
          for _i392 in xrange(_size388):
19812 
            _key393 = iprot.readString();
19813 
            _val394 = BrandInfo()
19814 
            _val394.read(iprot)
19815 
            self.success[_key393] = _val394
7272 amit.gupta 19816 
          iprot.readMapEnd()
19817 
        else:
19818 
          iprot.skip(ftype)
19819 
      else:
19820 
        iprot.skip(ftype)
19821 
      iprot.readFieldEnd()
19822 
    iprot.readStructEnd()
19823 
 
19824 
  def write(self, oprot):
19825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19827 
      return
19828 
    oprot.writeStructBegin('getBrandInfo_result')
19829 
    if self.success is not None:
19830 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19831 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19832 
      for kiter395,viter396 in self.success.items():
19833 
        oprot.writeString(kiter395)
19834 
        viter396.write(oprot)
7272 amit.gupta 19835 
      oprot.writeMapEnd()
19836 
      oprot.writeFieldEnd()
19837 
    oprot.writeFieldStop()
19838 
    oprot.writeStructEnd()
19839 
 
19840 
  def validate(self):
19841 
    return
19842 
 
19843 
 
19844 
  def __repr__(self):
19845 
    L = ['%s=%r' % (key, value)
19846 
      for key, value in self.__dict__.iteritems()]
19847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19848 
 
19849 
  def __eq__(self, other):
19850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19851 
 
19852 
  def __ne__(self, other):
19853 
    return not (self == other)
19854 
 
7256 rajveer 19855 
class getStorePricing_args:
19856 
  """
19857 
  Attributes:
19858 
   - itemId
19859 
  """
19860 
 
19861 
  thrift_spec = (
19862 
    None, # 0
19863 
    (1, TType.I64, 'itemId', None, None, ), # 1
19864 
  )
19865 
 
19866 
  def __init__(self, itemId=None,):
19867 
    self.itemId = itemId
19868 
 
19869 
  def read(self, iprot):
19870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19872 
      return
19873 
    iprot.readStructBegin()
19874 
    while True:
19875 
      (fname, ftype, fid) = iprot.readFieldBegin()
19876 
      if ftype == TType.STOP:
19877 
        break
19878 
      if fid == 1:
19879 
        if ftype == TType.I64:
19880 
          self.itemId = iprot.readI64();
19881 
        else:
19882 
          iprot.skip(ftype)
19883 
      else:
19884 
        iprot.skip(ftype)
19885 
      iprot.readFieldEnd()
19886 
    iprot.readStructEnd()
19887 
 
19888 
  def write(self, oprot):
19889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19891 
      return
19892 
    oprot.writeStructBegin('getStorePricing_args')
19893 
    if self.itemId is not None:
19894 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19895 
      oprot.writeI64(self.itemId)
19896 
      oprot.writeFieldEnd()
19897 
    oprot.writeFieldStop()
19898 
    oprot.writeStructEnd()
19899 
 
19900 
  def validate(self):
19901 
    return
19902 
 
19903 
 
19904 
  def __repr__(self):
19905 
    L = ['%s=%r' % (key, value)
19906 
      for key, value in self.__dict__.iteritems()]
19907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19908 
 
19909 
  def __eq__(self, other):
19910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19911 
 
19912 
  def __ne__(self, other):
19913 
    return not (self == other)
19914 
 
19915 
class getStorePricing_result:
19916 
  """
19917 
  Attributes:
19918 
   - success
19919 
  """
19920 
 
19921 
  thrift_spec = (
19922 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19923 
  )
19924 
 
19925 
  def __init__(self, success=None,):
19926 
    self.success = success
19927 
 
19928 
  def read(self, iprot):
19929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19931 
      return
19932 
    iprot.readStructBegin()
19933 
    while True:
19934 
      (fname, ftype, fid) = iprot.readFieldBegin()
19935 
      if ftype == TType.STOP:
19936 
        break
19937 
      if fid == 0:
19938 
        if ftype == TType.STRUCT:
19939 
          self.success = StorePricing()
19940 
          self.success.read(iprot)
19941 
        else:
19942 
          iprot.skip(ftype)
19943 
      else:
19944 
        iprot.skip(ftype)
19945 
      iprot.readFieldEnd()
19946 
    iprot.readStructEnd()
19947 
 
19948 
  def write(self, oprot):
19949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19951 
      return
19952 
    oprot.writeStructBegin('getStorePricing_result')
19953 
    if self.success is not None:
19954 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19955 
      self.success.write(oprot)
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)
7265 rajveer 19974 
 
7306 rajveer 19975 
class getStorePricings_args:
19976 
  """
19977 
  Attributes:
19978 
   - itemIds
19979 
  """
19980 
 
19981 
  thrift_spec = (
19982 
    None, # 0
19983 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19984 
  )
19985 
 
19986 
  def __init__(self, itemIds=None,):
19987 
    self.itemIds = itemIds
19988 
 
19989 
  def read(self, iprot):
19990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19992 
      return
19993 
    iprot.readStructBegin()
19994 
    while True:
19995 
      (fname, ftype, fid) = iprot.readFieldBegin()
19996 
      if ftype == TType.STOP:
19997 
        break
19998 
      if fid == 1:
19999 
        if ftype == TType.LIST:
20000 
          self.itemIds = []
9155 kshitij.so 20001 
          (_etype400, _size397) = iprot.readListBegin()
20002 
          for _i401 in xrange(_size397):
20003 
            _elem402 = iprot.readI64();
20004 
            self.itemIds.append(_elem402)
7306 rajveer 20005 
          iprot.readListEnd()
20006 
        else:
20007 
          iprot.skip(ftype)
20008 
      else:
20009 
        iprot.skip(ftype)
20010 
      iprot.readFieldEnd()
20011 
    iprot.readStructEnd()
20012 
 
20013 
  def write(self, oprot):
20014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20016 
      return
20017 
    oprot.writeStructBegin('getStorePricings_args')
20018 
    if self.itemIds is not None:
20019 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20020 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20021 
      for iter403 in self.itemIds:
20022 
        oprot.writeI64(iter403)
7306 rajveer 20023 
      oprot.writeListEnd()
20024 
      oprot.writeFieldEnd()
20025 
    oprot.writeFieldStop()
20026 
    oprot.writeStructEnd()
20027 
 
20028 
  def validate(self):
20029 
    return
20030 
 
20031 
 
20032 
  def __repr__(self):
20033 
    L = ['%s=%r' % (key, value)
20034 
      for key, value in self.__dict__.iteritems()]
20035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20036 
 
20037 
  def __eq__(self, other):
20038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20039 
 
20040 
  def __ne__(self, other):
20041 
    return not (self == other)
20042 
 
20043 
class getStorePricings_result:
20044 
  """
20045 
  Attributes:
20046 
   - success
20047 
  """
20048 
 
20049 
  thrift_spec = (
20050 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20051 
  )
20052 
 
20053 
  def __init__(self, success=None,):
20054 
    self.success = success
20055 
 
20056 
  def read(self, iprot):
20057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20059 
      return
20060 
    iprot.readStructBegin()
20061 
    while True:
20062 
      (fname, ftype, fid) = iprot.readFieldBegin()
20063 
      if ftype == TType.STOP:
20064 
        break
20065 
      if fid == 0:
20066 
        if ftype == TType.LIST:
20067 
          self.success = []
9155 kshitij.so 20068 
          (_etype407, _size404) = iprot.readListBegin()
20069 
          for _i408 in xrange(_size404):
20070 
            _elem409 = StorePricing()
20071 
            _elem409.read(iprot)
20072 
            self.success.append(_elem409)
7306 rajveer 20073 
          iprot.readListEnd()
20074 
        else:
20075 
          iprot.skip(ftype)
20076 
      else:
20077 
        iprot.skip(ftype)
20078 
      iprot.readFieldEnd()
20079 
    iprot.readStructEnd()
20080 
 
20081 
  def write(self, oprot):
20082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20084 
      return
20085 
    oprot.writeStructBegin('getStorePricings_result')
20086 
    if self.success is not None:
20087 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20088 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20089 
      for iter410 in self.success:
20090 
        iter410.write(oprot)
7306 rajveer 20091 
      oprot.writeListEnd()
20092 
      oprot.writeFieldEnd()
20093 
    oprot.writeFieldStop()
20094 
    oprot.writeStructEnd()
20095 
 
20096 
  def validate(self):
20097 
    return
20098 
 
20099 
 
20100 
  def __repr__(self):
20101 
    L = ['%s=%r' % (key, value)
20102 
      for key, value in self.__dict__.iteritems()]
20103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20104 
 
20105 
  def __eq__(self, other):
20106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20107 
 
20108 
  def __ne__(self, other):
20109 
    return not (self == other)
20110 
 
7265 rajveer 20111 
class updateStorePricing_args:
20112 
  """
20113 
  Attributes:
20114 
   - sp
7382 rajveer 20115 
   - allColors
7265 rajveer 20116 
  """
20117 
 
20118 
  thrift_spec = (
20119 
    None, # 0
20120 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20121 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20122 
  )
20123 
 
7382 rajveer 20124 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20125 
    self.sp = sp
7382 rajveer 20126 
    self.allColors = allColors
7265 rajveer 20127 
 
20128 
  def read(self, iprot):
20129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20131 
      return
20132 
    iprot.readStructBegin()
20133 
    while True:
20134 
      (fname, ftype, fid) = iprot.readFieldBegin()
20135 
      if ftype == TType.STOP:
20136 
        break
20137 
      if fid == 1:
20138 
        if ftype == TType.STRUCT:
20139 
          self.sp = StorePricing()
20140 
          self.sp.read(iprot)
20141 
        else:
20142 
          iprot.skip(ftype)
7382 rajveer 20143 
      elif fid == 2:
20144 
        if ftype == TType.BOOL:
20145 
          self.allColors = iprot.readBool();
20146 
        else:
20147 
          iprot.skip(ftype)
7265 rajveer 20148 
      else:
20149 
        iprot.skip(ftype)
20150 
      iprot.readFieldEnd()
20151 
    iprot.readStructEnd()
20152 
 
20153 
  def write(self, oprot):
20154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20156 
      return
20157 
    oprot.writeStructBegin('updateStorePricing_args')
20158 
    if self.sp is not None:
20159 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20160 
      self.sp.write(oprot)
20161 
      oprot.writeFieldEnd()
7382 rajveer 20162 
    if self.allColors is not None:
20163 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20164 
      oprot.writeBool(self.allColors)
20165 
      oprot.writeFieldEnd()
7265 rajveer 20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
20184 
class updateStorePricing_result:
20185 
 
20186 
  thrift_spec = (
20187 
  )
20188 
 
20189 
  def read(self, iprot):
20190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20192 
      return
20193 
    iprot.readStructBegin()
20194 
    while True:
20195 
      (fname, ftype, fid) = iprot.readFieldBegin()
20196 
      if ftype == TType.STOP:
20197 
        break
20198 
      else:
20199 
        iprot.skip(ftype)
20200 
      iprot.readFieldEnd()
20201 
    iprot.readStructEnd()
20202 
 
20203 
  def write(self, oprot):
20204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20206 
      return
20207 
    oprot.writeStructBegin('updateStorePricing_result')
20208 
    oprot.writeFieldStop()
20209 
    oprot.writeStructEnd()
20210 
 
20211 
  def validate(self):
20212 
    return
20213 
 
20214 
 
20215 
  def __repr__(self):
20216 
    L = ['%s=%r' % (key, value)
20217 
      for key, value in self.__dict__.iteritems()]
20218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20219 
 
20220 
  def __eq__(self, other):
20221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20222 
 
20223 
  def __ne__(self, other):
20224 
    return not (self == other)
7281 kshitij.so 20225 
 
20226 
class getAllAmazonListedItems_args:
20227 
 
20228 
  thrift_spec = (
20229 
  )
20230 
 
20231 
  def read(self, iprot):
20232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20234 
      return
20235 
    iprot.readStructBegin()
20236 
    while True:
20237 
      (fname, ftype, fid) = iprot.readFieldBegin()
20238 
      if ftype == TType.STOP:
20239 
        break
20240 
      else:
20241 
        iprot.skip(ftype)
20242 
      iprot.readFieldEnd()
20243 
    iprot.readStructEnd()
20244 
 
20245 
  def write(self, oprot):
20246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20248 
      return
20249 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20250 
    oprot.writeFieldStop()
20251 
    oprot.writeStructEnd()
20252 
 
20253 
  def validate(self):
20254 
    return
20255 
 
20256 
 
20257 
  def __repr__(self):
20258 
    L = ['%s=%r' % (key, value)
20259 
      for key, value in self.__dict__.iteritems()]
20260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20261 
 
20262 
  def __eq__(self, other):
20263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20264 
 
20265 
  def __ne__(self, other):
20266 
    return not (self == other)
20267 
 
20268 
class getAllAmazonListedItems_result:
20269 
  """
20270 
  Attributes:
20271 
   - success
20272 
  """
20273 
 
20274 
  thrift_spec = (
20275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20276 
  )
20277 
 
20278 
  def __init__(self, success=None,):
20279 
    self.success = success
20280 
 
20281 
  def read(self, iprot):
20282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20284 
      return
20285 
    iprot.readStructBegin()
20286 
    while True:
20287 
      (fname, ftype, fid) = iprot.readFieldBegin()
20288 
      if ftype == TType.STOP:
20289 
        break
20290 
      if fid == 0:
20291 
        if ftype == TType.LIST:
20292 
          self.success = []
9155 kshitij.so 20293 
          (_etype414, _size411) = iprot.readListBegin()
20294 
          for _i415 in xrange(_size411):
20295 
            _elem416 = Amazonlisted()
20296 
            _elem416.read(iprot)
20297 
            self.success.append(_elem416)
7281 kshitij.so 20298 
          iprot.readListEnd()
20299 
        else:
20300 
          iprot.skip(ftype)
20301 
      else:
20302 
        iprot.skip(ftype)
20303 
      iprot.readFieldEnd()
20304 
    iprot.readStructEnd()
20305 
 
20306 
  def write(self, oprot):
20307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20309 
      return
20310 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20311 
    if self.success is not None:
20312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20314 
      for iter417 in self.success:
20315 
        iter417.write(oprot)
7281 kshitij.so 20316 
      oprot.writeListEnd()
20317 
      oprot.writeFieldEnd()
20318 
    oprot.writeFieldStop()
20319 
    oprot.writeStructEnd()
20320 
 
20321 
  def validate(self):
20322 
    return
20323 
 
20324 
 
20325 
  def __repr__(self):
20326 
    L = ['%s=%r' % (key, value)
20327 
      for key, value in self.__dict__.iteritems()]
20328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20329 
 
20330 
  def __eq__(self, other):
20331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20332 
 
20333 
  def __ne__(self, other):
20334 
    return not (self == other)
20335 
 
8619 kshitij.so 20336 
class searchAmazonItems_args:
20337 
  """
20338 
  Attributes:
20339 
   - searchTerm
20340 
   - offset
20341 
   - limit
20342 
  """
20343 
 
20344 
  thrift_spec = (
20345 
    None, # 0
20346 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20347 
    (2, TType.I64, 'offset', None, None, ), # 2
20348 
    (3, TType.I64, 'limit', None, None, ), # 3
20349 
  )
20350 
 
20351 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20352 
    self.searchTerm = searchTerm
20353 
    self.offset = offset
20354 
    self.limit = limit
20355 
 
20356 
  def read(self, iprot):
20357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20359 
      return
20360 
    iprot.readStructBegin()
20361 
    while True:
20362 
      (fname, ftype, fid) = iprot.readFieldBegin()
20363 
      if ftype == TType.STOP:
20364 
        break
20365 
      if fid == 1:
20366 
        if ftype == TType.LIST:
20367 
          self.searchTerm = []
9155 kshitij.so 20368 
          (_etype421, _size418) = iprot.readListBegin()
20369 
          for _i422 in xrange(_size418):
20370 
            _elem423 = iprot.readString();
20371 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20372 
          iprot.readListEnd()
20373 
        else:
20374 
          iprot.skip(ftype)
20375 
      elif fid == 2:
20376 
        if ftype == TType.I64:
20377 
          self.offset = iprot.readI64();
20378 
        else:
20379 
          iprot.skip(ftype)
20380 
      elif fid == 3:
20381 
        if ftype == TType.I64:
20382 
          self.limit = iprot.readI64();
20383 
        else:
20384 
          iprot.skip(ftype)
20385 
      else:
20386 
        iprot.skip(ftype)
20387 
      iprot.readFieldEnd()
20388 
    iprot.readStructEnd()
20389 
 
20390 
  def write(self, oprot):
20391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20393 
      return
20394 
    oprot.writeStructBegin('searchAmazonItems_args')
20395 
    if self.searchTerm is not None:
20396 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20397 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20398 
      for iter424 in self.searchTerm:
20399 
        oprot.writeString(iter424)
8619 kshitij.so 20400 
      oprot.writeListEnd()
20401 
      oprot.writeFieldEnd()
20402 
    if self.offset is not None:
20403 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20404 
      oprot.writeI64(self.offset)
20405 
      oprot.writeFieldEnd()
20406 
    if self.limit is not None:
20407 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20408 
      oprot.writeI64(self.limit)
20409 
      oprot.writeFieldEnd()
20410 
    oprot.writeFieldStop()
20411 
    oprot.writeStructEnd()
20412 
 
20413 
  def validate(self):
20414 
    return
20415 
 
20416 
 
20417 
  def __repr__(self):
20418 
    L = ['%s=%r' % (key, value)
20419 
      for key, value in self.__dict__.iteritems()]
20420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20421 
 
20422 
  def __eq__(self, other):
20423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20424 
 
20425 
  def __ne__(self, other):
20426 
    return not (self == other)
20427 
 
20428 
class searchAmazonItems_result:
20429 
  """
20430 
  Attributes:
20431 
   - success
20432 
  """
20433 
 
20434 
  thrift_spec = (
20435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20436 
  )
20437 
 
20438 
  def __init__(self, success=None,):
20439 
    self.success = success
20440 
 
20441 
  def read(self, iprot):
20442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20444 
      return
20445 
    iprot.readStructBegin()
20446 
    while True:
20447 
      (fname, ftype, fid) = iprot.readFieldBegin()
20448 
      if ftype == TType.STOP:
20449 
        break
20450 
      if fid == 0:
20451 
        if ftype == TType.LIST:
20452 
          self.success = []
9155 kshitij.so 20453 
          (_etype428, _size425) = iprot.readListBegin()
20454 
          for _i429 in xrange(_size425):
20455 
            _elem430 = Amazonlisted()
20456 
            _elem430.read(iprot)
20457 
            self.success.append(_elem430)
8619 kshitij.so 20458 
          iprot.readListEnd()
20459 
        else:
20460 
          iprot.skip(ftype)
20461 
      else:
20462 
        iprot.skip(ftype)
20463 
      iprot.readFieldEnd()
20464 
    iprot.readStructEnd()
20465 
 
20466 
  def write(self, oprot):
20467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20469 
      return
20470 
    oprot.writeStructBegin('searchAmazonItems_result')
20471 
    if self.success is not None:
20472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20474 
      for iter431 in self.success:
20475 
        iter431.write(oprot)
8619 kshitij.so 20476 
      oprot.writeListEnd()
20477 
      oprot.writeFieldEnd()
20478 
    oprot.writeFieldStop()
20479 
    oprot.writeStructEnd()
20480 
 
20481 
  def validate(self):
20482 
    return
20483 
 
20484 
 
20485 
  def __repr__(self):
20486 
    L = ['%s=%r' % (key, value)
20487 
      for key, value in self.__dict__.iteritems()]
20488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20489 
 
20490 
  def __eq__(self, other):
20491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20492 
 
20493 
  def __ne__(self, other):
20494 
    return not (self == other)
20495 
 
20496 
class getAmazonSearchResultCount_args:
20497 
  """
20498 
  Attributes:
20499 
   - searchTerm
20500 
  """
20501 
 
20502 
  thrift_spec = (
20503 
    None, # 0
20504 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20505 
  )
20506 
 
20507 
  def __init__(self, searchTerm=None,):
20508 
    self.searchTerm = searchTerm
20509 
 
20510 
  def read(self, iprot):
20511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20513 
      return
20514 
    iprot.readStructBegin()
20515 
    while True:
20516 
      (fname, ftype, fid) = iprot.readFieldBegin()
20517 
      if ftype == TType.STOP:
20518 
        break
20519 
      if fid == 1:
20520 
        if ftype == TType.LIST:
20521 
          self.searchTerm = []
9155 kshitij.so 20522 
          (_etype435, _size432) = iprot.readListBegin()
20523 
          for _i436 in xrange(_size432):
20524 
            _elem437 = iprot.readString();
20525 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20526 
          iprot.readListEnd()
20527 
        else:
20528 
          iprot.skip(ftype)
20529 
      else:
20530 
        iprot.skip(ftype)
20531 
      iprot.readFieldEnd()
20532 
    iprot.readStructEnd()
20533 
 
20534 
  def write(self, oprot):
20535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20537 
      return
20538 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20539 
    if self.searchTerm is not None:
20540 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20541 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20542 
      for iter438 in self.searchTerm:
20543 
        oprot.writeString(iter438)
8619 kshitij.so 20544 
      oprot.writeListEnd()
20545 
      oprot.writeFieldEnd()
20546 
    oprot.writeFieldStop()
20547 
    oprot.writeStructEnd()
20548 
 
20549 
  def validate(self):
20550 
    return
20551 
 
20552 
 
20553 
  def __repr__(self):
20554 
    L = ['%s=%r' % (key, value)
20555 
      for key, value in self.__dict__.iteritems()]
20556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20557 
 
20558 
  def __eq__(self, other):
20559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20560 
 
20561 
  def __ne__(self, other):
20562 
    return not (self == other)
20563 
 
20564 
class getAmazonSearchResultCount_result:
20565 
  """
20566 
  Attributes:
20567 
   - success
20568 
  """
20569 
 
20570 
  thrift_spec = (
20571 
    (0, TType.I64, 'success', None, None, ), # 0
20572 
  )
20573 
 
20574 
  def __init__(self, success=None,):
20575 
    self.success = success
20576 
 
20577 
  def read(self, iprot):
20578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20580 
      return
20581 
    iprot.readStructBegin()
20582 
    while True:
20583 
      (fname, ftype, fid) = iprot.readFieldBegin()
20584 
      if ftype == TType.STOP:
20585 
        break
20586 
      if fid == 0:
20587 
        if ftype == TType.I64:
20588 
          self.success = iprot.readI64();
20589 
        else:
20590 
          iprot.skip(ftype)
20591 
      else:
20592 
        iprot.skip(ftype)
20593 
      iprot.readFieldEnd()
20594 
    iprot.readStructEnd()
20595 
 
20596 
  def write(self, oprot):
20597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20599 
      return
20600 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20601 
    if self.success is not None:
20602 
      oprot.writeFieldBegin('success', TType.I64, 0)
20603 
      oprot.writeI64(self.success)
20604 
      oprot.writeFieldEnd()
20605 
    oprot.writeFieldStop()
20606 
    oprot.writeStructEnd()
20607 
 
20608 
  def validate(self):
20609 
    return
20610 
 
20611 
 
20612 
  def __repr__(self):
20613 
    L = ['%s=%r' % (key, value)
20614 
      for key, value in self.__dict__.iteritems()]
20615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20616 
 
20617 
  def __eq__(self, other):
20618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20619 
 
20620 
  def __ne__(self, other):
20621 
    return not (self == other)
20622 
 
20623 
class getCountForAmazonlistedItems_args:
20624 
 
20625 
  thrift_spec = (
20626 
  )
20627 
 
20628 
  def read(self, iprot):
20629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20631 
      return
20632 
    iprot.readStructBegin()
20633 
    while True:
20634 
      (fname, ftype, fid) = iprot.readFieldBegin()
20635 
      if ftype == TType.STOP:
20636 
        break
20637 
      else:
20638 
        iprot.skip(ftype)
20639 
      iprot.readFieldEnd()
20640 
    iprot.readStructEnd()
20641 
 
20642 
  def write(self, oprot):
20643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20645 
      return
20646 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20647 
    oprot.writeFieldStop()
20648 
    oprot.writeStructEnd()
20649 
 
20650 
  def validate(self):
20651 
    return
20652 
 
20653 
 
20654 
  def __repr__(self):
20655 
    L = ['%s=%r' % (key, value)
20656 
      for key, value in self.__dict__.iteritems()]
20657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20658 
 
20659 
  def __eq__(self, other):
20660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20661 
 
20662 
  def __ne__(self, other):
20663 
    return not (self == other)
20664 
 
20665 
class getCountForAmazonlistedItems_result:
20666 
  """
20667 
  Attributes:
20668 
   - success
20669 
  """
20670 
 
20671 
  thrift_spec = (
20672 
    (0, TType.I64, 'success', None, None, ), # 0
20673 
  )
20674 
 
20675 
  def __init__(self, success=None,):
20676 
    self.success = success
20677 
 
20678 
  def read(self, iprot):
20679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20681 
      return
20682 
    iprot.readStructBegin()
20683 
    while True:
20684 
      (fname, ftype, fid) = iprot.readFieldBegin()
20685 
      if ftype == TType.STOP:
20686 
        break
20687 
      if fid == 0:
20688 
        if ftype == TType.I64:
20689 
          self.success = iprot.readI64();
20690 
        else:
20691 
          iprot.skip(ftype)
20692 
      else:
20693 
        iprot.skip(ftype)
20694 
      iprot.readFieldEnd()
20695 
    iprot.readStructEnd()
20696 
 
20697 
  def write(self, oprot):
20698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20700 
      return
20701 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20702 
    if self.success is not None:
20703 
      oprot.writeFieldBegin('success', TType.I64, 0)
20704 
      oprot.writeI64(self.success)
20705 
      oprot.writeFieldEnd()
20706 
    oprot.writeFieldStop()
20707 
    oprot.writeStructEnd()
20708 
 
20709 
  def validate(self):
20710 
    return
20711 
 
20712 
 
20713 
  def __repr__(self):
20714 
    L = ['%s=%r' % (key, value)
20715 
      for key, value in self.__dict__.iteritems()]
20716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20717 
 
20718 
  def __eq__(self, other):
20719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20720 
 
20721 
  def __ne__(self, other):
20722 
    return not (self == other)
20723 
 
7281 kshitij.so 20724 
class getAmazonItemDetails_args:
20725 
  """
20726 
  Attributes:
20727 
   - itemId
20728 
  """
20729 
 
20730 
  thrift_spec = (
20731 
    None, # 0
20732 
    (1, TType.I64, 'itemId', None, None, ), # 1
20733 
  )
20734 
 
20735 
  def __init__(self, itemId=None,):
20736 
    self.itemId = itemId
20737 
 
20738 
  def read(self, iprot):
20739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20741 
      return
20742 
    iprot.readStructBegin()
20743 
    while True:
20744 
      (fname, ftype, fid) = iprot.readFieldBegin()
20745 
      if ftype == TType.STOP:
20746 
        break
20747 
      if fid == 1:
20748 
        if ftype == TType.I64:
20749 
          self.itemId = iprot.readI64();
20750 
        else:
20751 
          iprot.skip(ftype)
20752 
      else:
20753 
        iprot.skip(ftype)
20754 
      iprot.readFieldEnd()
20755 
    iprot.readStructEnd()
20756 
 
20757 
  def write(self, oprot):
20758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20760 
      return
20761 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20762 
    if self.itemId is not None:
20763 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20764 
      oprot.writeI64(self.itemId)
20765 
      oprot.writeFieldEnd()
20766 
    oprot.writeFieldStop()
20767 
    oprot.writeStructEnd()
20768 
 
20769 
  def validate(self):
20770 
    return
20771 
 
20772 
 
20773 
  def __repr__(self):
20774 
    L = ['%s=%r' % (key, value)
20775 
      for key, value in self.__dict__.iteritems()]
20776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20777 
 
20778 
  def __eq__(self, other):
20779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20780 
 
20781 
  def __ne__(self, other):
20782 
    return not (self == other)
20783 
 
20784 
class getAmazonItemDetails_result:
20785 
  """
20786 
  Attributes:
20787 
   - success
20788 
  """
20789 
 
20790 
  thrift_spec = (
20791 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20792 
  )
20793 
 
20794 
  def __init__(self, success=None,):
20795 
    self.success = success
20796 
 
20797 
  def read(self, iprot):
20798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20800 
      return
20801 
    iprot.readStructBegin()
20802 
    while True:
20803 
      (fname, ftype, fid) = iprot.readFieldBegin()
20804 
      if ftype == TType.STOP:
20805 
        break
20806 
      if fid == 0:
20807 
        if ftype == TType.STRUCT:
20808 
          self.success = Amazonlisted()
20809 
          self.success.read(iprot)
20810 
        else:
20811 
          iprot.skip(ftype)
20812 
      else:
20813 
        iprot.skip(ftype)
20814 
      iprot.readFieldEnd()
20815 
    iprot.readStructEnd()
20816 
 
20817 
  def write(self, oprot):
20818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20820 
      return
20821 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20822 
    if self.success is not None:
20823 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20824 
      self.success.write(oprot)
20825 
      oprot.writeFieldEnd()
20826 
    oprot.writeFieldStop()
20827 
    oprot.writeStructEnd()
20828 
 
20829 
  def validate(self):
20830 
    return
20831 
 
20832 
 
20833 
  def __repr__(self):
20834 
    L = ['%s=%r' % (key, value)
20835 
      for key, value in self.__dict__.iteritems()]
20836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20837 
 
20838 
  def __eq__(self, other):
20839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20840 
 
20841 
  def __ne__(self, other):
20842 
    return not (self == other)
20843 
 
20844 
class updateAmazonItemDetails_args:
20845 
  """
20846 
  Attributes:
8168 kshitij.so 20847 
   - amazonlisted
7281 kshitij.so 20848 
  """
20849 
 
20850 
  thrift_spec = (
20851 
    None, # 0
8168 kshitij.so 20852 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20853 
  )
20854 
 
8168 kshitij.so 20855 
  def __init__(self, amazonlisted=None,):
20856 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20857 
 
20858 
  def read(self, iprot):
20859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20861 
      return
20862 
    iprot.readStructBegin()
20863 
    while True:
20864 
      (fname, ftype, fid) = iprot.readFieldBegin()
20865 
      if ftype == TType.STOP:
20866 
        break
20867 
      if fid == 1:
8168 kshitij.so 20868 
        if ftype == TType.STRUCT:
20869 
          self.amazonlisted = Amazonlisted()
20870 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20871 
        else:
20872 
          iprot.skip(ftype)
20873 
      else:
20874 
        iprot.skip(ftype)
20875 
      iprot.readFieldEnd()
20876 
    iprot.readStructEnd()
20877 
 
20878 
  def write(self, oprot):
20879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20881 
      return
20882 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20883 
    if self.amazonlisted is not None:
20884 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20885 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20886 
      oprot.writeFieldEnd()
20887 
    oprot.writeFieldStop()
20888 
    oprot.writeStructEnd()
20889 
 
20890 
  def validate(self):
20891 
    return
20892 
 
20893 
 
20894 
  def __repr__(self):
20895 
    L = ['%s=%r' % (key, value)
20896 
      for key, value in self.__dict__.iteritems()]
20897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20898 
 
20899 
  def __eq__(self, other):
20900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20901 
 
20902 
  def __ne__(self, other):
20903 
    return not (self == other)
20904 
 
20905 
class updateAmazonItemDetails_result:
20906 
 
20907 
  thrift_spec = (
20908 
  )
20909 
 
20910 
  def read(self, iprot):
20911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20913 
      return
20914 
    iprot.readStructBegin()
20915 
    while True:
20916 
      (fname, ftype, fid) = iprot.readFieldBegin()
20917 
      if ftype == TType.STOP:
20918 
        break
20919 
      else:
20920 
        iprot.skip(ftype)
20921 
      iprot.readFieldEnd()
20922 
    iprot.readStructEnd()
20923 
 
20924 
  def write(self, oprot):
20925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20927 
      return
20928 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20929 
    oprot.writeFieldStop()
20930 
    oprot.writeStructEnd()
20931 
 
20932 
  def validate(self):
20933 
    return
20934 
 
20935 
 
20936 
  def __repr__(self):
20937 
    L = ['%s=%r' % (key, value)
20938 
      for key, value in self.__dict__.iteritems()]
20939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20940 
 
20941 
  def __eq__(self, other):
20942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20943 
 
20944 
  def __ne__(self, other):
20945 
    return not (self == other)
20946 
 
20947 
class addAmazonItem_args:
20948 
  """
20949 
  Attributes:
20950 
   - amazonlisted
20951 
  """
20952 
 
20953 
  thrift_spec = (
20954 
    None, # 0
20955 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20956 
  )
20957 
 
20958 
  def __init__(self, amazonlisted=None,):
20959 
    self.amazonlisted = amazonlisted
20960 
 
20961 
  def read(self, iprot):
20962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20964 
      return
20965 
    iprot.readStructBegin()
20966 
    while True:
20967 
      (fname, ftype, fid) = iprot.readFieldBegin()
20968 
      if ftype == TType.STOP:
20969 
        break
20970 
      if fid == 1:
20971 
        if ftype == TType.STRUCT:
20972 
          self.amazonlisted = Amazonlisted()
20973 
          self.amazonlisted.read(iprot)
20974 
        else:
20975 
          iprot.skip(ftype)
20976 
      else:
20977 
        iprot.skip(ftype)
20978 
      iprot.readFieldEnd()
20979 
    iprot.readStructEnd()
20980 
 
20981 
  def write(self, oprot):
20982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20984 
      return
20985 
    oprot.writeStructBegin('addAmazonItem_args')
20986 
    if self.amazonlisted is not None:
20987 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20988 
      self.amazonlisted.write(oprot)
20989 
      oprot.writeFieldEnd()
20990 
    oprot.writeFieldStop()
20991 
    oprot.writeStructEnd()
20992 
 
20993 
  def validate(self):
20994 
    return
20995 
 
20996 
 
20997 
  def __repr__(self):
20998 
    L = ['%s=%r' % (key, value)
20999 
      for key, value in self.__dict__.iteritems()]
21000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21001 
 
21002 
  def __eq__(self, other):
21003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21004 
 
21005 
  def __ne__(self, other):
21006 
    return not (self == other)
21007 
 
21008 
class addAmazonItem_result:
21009 
 
21010 
  thrift_spec = (
21011 
  )
21012 
 
21013 
  def read(self, iprot):
21014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21016 
      return
21017 
    iprot.readStructBegin()
21018 
    while True:
21019 
      (fname, ftype, fid) = iprot.readFieldBegin()
21020 
      if ftype == TType.STOP:
21021 
        break
21022 
      else:
21023 
        iprot.skip(ftype)
21024 
      iprot.readFieldEnd()
21025 
    iprot.readStructEnd()
21026 
 
21027 
  def write(self, oprot):
21028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21030 
      return
21031 
    oprot.writeStructBegin('addAmazonItem_result')
21032 
    oprot.writeFieldStop()
21033 
    oprot.writeStructEnd()
21034 
 
21035 
  def validate(self):
21036 
    return
21037 
 
21038 
 
21039 
  def __repr__(self):
21040 
    L = ['%s=%r' % (key, value)
21041 
      for key, value in self.__dict__.iteritems()]
21042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21043 
 
21044 
  def __eq__(self, other):
21045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21046 
 
21047 
  def __ne__(self, other):
21048 
    return not (self == other)
7291 vikram.rag 21049 
 
21050 
class getAsinItems_args:
21051 
 
21052 
  thrift_spec = (
21053 
  )
21054 
 
21055 
  def read(self, iprot):
21056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21058 
      return
21059 
    iprot.readStructBegin()
21060 
    while True:
21061 
      (fname, ftype, fid) = iprot.readFieldBegin()
21062 
      if ftype == TType.STOP:
21063 
        break
21064 
      else:
21065 
        iprot.skip(ftype)
21066 
      iprot.readFieldEnd()
21067 
    iprot.readStructEnd()
21068 
 
21069 
  def write(self, oprot):
21070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21072 
      return
21073 
    oprot.writeStructBegin('getAsinItems_args')
21074 
    oprot.writeFieldStop()
21075 
    oprot.writeStructEnd()
21076 
 
21077 
  def validate(self):
21078 
    return
21079 
 
21080 
 
21081 
  def __repr__(self):
21082 
    L = ['%s=%r' % (key, value)
21083 
      for key, value in self.__dict__.iteritems()]
21084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21085 
 
21086 
  def __eq__(self, other):
21087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21088 
 
21089 
  def __ne__(self, other):
21090 
    return not (self == other)
21091 
 
21092 
class getAsinItems_result:
21093 
  """
21094 
  Attributes:
21095 
   - success
21096 
  """
21097 
 
21098 
  thrift_spec = (
21099 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21100 
  )
21101 
 
21102 
  def __init__(self, success=None,):
21103 
    self.success = success
21104 
 
21105 
  def read(self, iprot):
21106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21108 
      return
21109 
    iprot.readStructBegin()
21110 
    while True:
21111 
      (fname, ftype, fid) = iprot.readFieldBegin()
21112 
      if ftype == TType.STOP:
21113 
        break
21114 
      if fid == 0:
21115 
        if ftype == TType.LIST:
21116 
          self.success = []
9155 kshitij.so 21117 
          (_etype442, _size439) = iprot.readListBegin()
21118 
          for _i443 in xrange(_size439):
21119 
            _elem444 = Item()
21120 
            _elem444.read(iprot)
21121 
            self.success.append(_elem444)
7291 vikram.rag 21122 
          iprot.readListEnd()
21123 
        else:
21124 
          iprot.skip(ftype)
21125 
      else:
21126 
        iprot.skip(ftype)
21127 
      iprot.readFieldEnd()
21128 
    iprot.readStructEnd()
21129 
 
21130 
  def write(self, oprot):
21131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21133 
      return
21134 
    oprot.writeStructBegin('getAsinItems_result')
21135 
    if self.success is not None:
21136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21138 
      for iter445 in self.success:
21139 
        iter445.write(oprot)
7291 vikram.rag 21140 
      oprot.writeListEnd()
21141 
      oprot.writeFieldEnd()
21142 
    oprot.writeFieldStop()
21143 
    oprot.writeStructEnd()
21144 
 
21145 
  def validate(self):
21146 
    return
21147 
 
21148 
 
21149 
  def __repr__(self):
21150 
    L = ['%s=%r' % (key, value)
21151 
      for key, value in self.__dict__.iteritems()]
21152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21153 
 
21154 
  def __eq__(self, other):
21155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21156 
 
21157 
  def __ne__(self, other):
21158 
    return not (self == other)
21159 
 
21160 
class getAllFbaListedItems_args:
21161 
 
21162 
  thrift_spec = (
21163 
  )
21164 
 
21165 
  def read(self, iprot):
21166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21168 
      return
21169 
    iprot.readStructBegin()
21170 
    while True:
21171 
      (fname, ftype, fid) = iprot.readFieldBegin()
21172 
      if ftype == TType.STOP:
21173 
        break
21174 
      else:
21175 
        iprot.skip(ftype)
21176 
      iprot.readFieldEnd()
21177 
    iprot.readStructEnd()
21178 
 
21179 
  def write(self, oprot):
21180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21182 
      return
21183 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21184 
    oprot.writeFieldStop()
21185 
    oprot.writeStructEnd()
21186 
 
21187 
  def validate(self):
21188 
    return
21189 
 
21190 
 
21191 
  def __repr__(self):
21192 
    L = ['%s=%r' % (key, value)
21193 
      for key, value in self.__dict__.iteritems()]
21194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21195 
 
21196 
  def __eq__(self, other):
21197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21198 
 
21199 
  def __ne__(self, other):
21200 
    return not (self == other)
21201 
 
21202 
class getAllFbaListedItems_result:
21203 
  """
21204 
  Attributes:
21205 
   - success
21206 
  """
21207 
 
21208 
  thrift_spec = (
21209 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21210 
  )
21211 
 
21212 
  def __init__(self, success=None,):
21213 
    self.success = success
21214 
 
21215 
  def read(self, iprot):
21216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21218 
      return
21219 
    iprot.readStructBegin()
21220 
    while True:
21221 
      (fname, ftype, fid) = iprot.readFieldBegin()
21222 
      if ftype == TType.STOP:
21223 
        break
21224 
      if fid == 0:
21225 
        if ftype == TType.LIST:
21226 
          self.success = []
9155 kshitij.so 21227 
          (_etype449, _size446) = iprot.readListBegin()
21228 
          for _i450 in xrange(_size446):
21229 
            _elem451 = Amazonlisted()
21230 
            _elem451.read(iprot)
21231 
            self.success.append(_elem451)
7291 vikram.rag 21232 
          iprot.readListEnd()
21233 
        else:
21234 
          iprot.skip(ftype)
21235 
      else:
21236 
        iprot.skip(ftype)
21237 
      iprot.readFieldEnd()
21238 
    iprot.readStructEnd()
21239 
 
21240 
  def write(self, oprot):
21241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21243 
      return
21244 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21245 
    if self.success is not None:
21246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21248 
      for iter452 in self.success:
21249 
        iter452.write(oprot)
7291 vikram.rag 21250 
      oprot.writeListEnd()
21251 
      oprot.writeFieldEnd()
21252 
    oprot.writeFieldStop()
21253 
    oprot.writeStructEnd()
21254 
 
21255 
  def validate(self):
21256 
    return
21257 
 
21258 
 
21259 
  def __repr__(self):
21260 
    L = ['%s=%r' % (key, value)
21261 
      for key, value in self.__dict__.iteritems()]
21262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21263 
 
21264 
  def __eq__(self, other):
21265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21266 
 
21267 
  def __ne__(self, other):
21268 
    return not (self == other)
21269 
 
21270 
class getAllNonFbaListedItems_args:
21271 
 
21272 
  thrift_spec = (
21273 
  )
21274 
 
21275 
  def read(self, iprot):
21276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21278 
      return
21279 
    iprot.readStructBegin()
21280 
    while True:
21281 
      (fname, ftype, fid) = iprot.readFieldBegin()
21282 
      if ftype == TType.STOP:
21283 
        break
21284 
      else:
21285 
        iprot.skip(ftype)
21286 
      iprot.readFieldEnd()
21287 
    iprot.readStructEnd()
21288 
 
21289 
  def write(self, oprot):
21290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21292 
      return
21293 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21294 
    oprot.writeFieldStop()
21295 
    oprot.writeStructEnd()
21296 
 
21297 
  def validate(self):
21298 
    return
21299 
 
21300 
 
21301 
  def __repr__(self):
21302 
    L = ['%s=%r' % (key, value)
21303 
      for key, value in self.__dict__.iteritems()]
21304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21305 
 
21306 
  def __eq__(self, other):
21307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21308 
 
21309 
  def __ne__(self, other):
21310 
    return not (self == other)
21311 
 
21312 
class getAllNonFbaListedItems_result:
21313 
  """
21314 
  Attributes:
21315 
   - success
21316 
  """
21317 
 
21318 
  thrift_spec = (
21319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21320 
  )
21321 
 
21322 
  def __init__(self, success=None,):
21323 
    self.success = success
21324 
 
21325 
  def read(self, iprot):
21326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21328 
      return
21329 
    iprot.readStructBegin()
21330 
    while True:
21331 
      (fname, ftype, fid) = iprot.readFieldBegin()
21332 
      if ftype == TType.STOP:
21333 
        break
21334 
      if fid == 0:
21335 
        if ftype == TType.LIST:
21336 
          self.success = []
9155 kshitij.so 21337 
          (_etype456, _size453) = iprot.readListBegin()
21338 
          for _i457 in xrange(_size453):
21339 
            _elem458 = Amazonlisted()
21340 
            _elem458.read(iprot)
21341 
            self.success.append(_elem458)
7291 vikram.rag 21342 
          iprot.readListEnd()
21343 
        else:
21344 
          iprot.skip(ftype)
21345 
      else:
21346 
        iprot.skip(ftype)
21347 
      iprot.readFieldEnd()
21348 
    iprot.readStructEnd()
21349 
 
21350 
  def write(self, oprot):
21351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21353 
      return
21354 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21355 
    if self.success is not None:
21356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21358 
      for iter459 in self.success:
21359 
        iter459.write(oprot)
7291 vikram.rag 21360 
      oprot.writeListEnd()
21361 
      oprot.writeFieldEnd()
21362 
    oprot.writeFieldStop()
21363 
    oprot.writeStructEnd()
21364 
 
21365 
  def validate(self):
21366 
    return
21367 
 
21368 
 
21369 
  def __repr__(self):
21370 
    L = ['%s=%r' % (key, value)
21371 
      for key, value in self.__dict__.iteritems()]
21372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21373 
 
21374 
  def __eq__(self, other):
21375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21376 
 
21377 
  def __ne__(self, other):
21378 
    return not (self == other)
7460 kshitij.so 21379 
 
21380 
class updateItemInventory_args:
21381 
  """
21382 
  Attributes:
21383 
   - itemId
21384 
   - holdInventory
21385 
   - defaultInventory
21386 
  """
21387 
 
21388 
  thrift_spec = (
21389 
    None, # 0
21390 
    (1, TType.I64, 'itemId', None, None, ), # 1
21391 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21392 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21393 
  )
21394 
 
21395 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21396 
    self.itemId = itemId
21397 
    self.holdInventory = holdInventory
21398 
    self.defaultInventory = defaultInventory
21399 
 
21400 
  def read(self, iprot):
21401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21403 
      return
21404 
    iprot.readStructBegin()
21405 
    while True:
21406 
      (fname, ftype, fid) = iprot.readFieldBegin()
21407 
      if ftype == TType.STOP:
21408 
        break
21409 
      if fid == 1:
21410 
        if ftype == TType.I64:
21411 
          self.itemId = iprot.readI64();
21412 
        else:
21413 
          iprot.skip(ftype)
21414 
      elif fid == 2:
21415 
        if ftype == TType.I64:
21416 
          self.holdInventory = iprot.readI64();
21417 
        else:
21418 
          iprot.skip(ftype)
21419 
      elif fid == 3:
21420 
        if ftype == TType.I64:
21421 
          self.defaultInventory = iprot.readI64();
21422 
        else:
21423 
          iprot.skip(ftype)
21424 
      else:
21425 
        iprot.skip(ftype)
21426 
      iprot.readFieldEnd()
21427 
    iprot.readStructEnd()
21428 
 
21429 
  def write(self, oprot):
21430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21432 
      return
21433 
    oprot.writeStructBegin('updateItemInventory_args')
21434 
    if self.itemId is not None:
21435 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21436 
      oprot.writeI64(self.itemId)
21437 
      oprot.writeFieldEnd()
21438 
    if self.holdInventory is not None:
21439 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21440 
      oprot.writeI64(self.holdInventory)
21441 
      oprot.writeFieldEnd()
21442 
    if self.defaultInventory is not None:
21443 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21444 
      oprot.writeI64(self.defaultInventory)
21445 
      oprot.writeFieldEnd()
21446 
    oprot.writeFieldStop()
21447 
    oprot.writeStructEnd()
21448 
 
21449 
  def validate(self):
21450 
    return
21451 
 
21452 
 
21453 
  def __repr__(self):
21454 
    L = ['%s=%r' % (key, value)
21455 
      for key, value in self.__dict__.iteritems()]
21456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21457 
 
21458 
  def __eq__(self, other):
21459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21460 
 
21461 
  def __ne__(self, other):
21462 
    return not (self == other)
21463 
 
21464 
class updateItemInventory_result:
21465 
  """
21466 
  Attributes:
21467 
   - success
21468 
  """
21469 
 
21470 
  thrift_spec = (
21471 
    (0, TType.BOOL, 'success', None, None, ), # 0
21472 
  )
21473 
 
21474 
  def __init__(self, success=None,):
21475 
    self.success = success
21476 
 
21477 
  def read(self, iprot):
21478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21480 
      return
21481 
    iprot.readStructBegin()
21482 
    while True:
21483 
      (fname, ftype, fid) = iprot.readFieldBegin()
21484 
      if ftype == TType.STOP:
21485 
        break
21486 
      if fid == 0:
21487 
        if ftype == TType.BOOL:
21488 
          self.success = iprot.readBool();
21489 
        else:
21490 
          iprot.skip(ftype)
21491 
      else:
21492 
        iprot.skip(ftype)
21493 
      iprot.readFieldEnd()
21494 
    iprot.readStructEnd()
21495 
 
21496 
  def write(self, oprot):
21497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21499 
      return
21500 
    oprot.writeStructBegin('updateItemInventory_result')
21501 
    if self.success is not None:
21502 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21503 
      oprot.writeBool(self.success)
21504 
      oprot.writeFieldEnd()
21505 
    oprot.writeFieldStop()
21506 
    oprot.writeStructEnd()
21507 
 
21508 
  def validate(self):
21509 
    return
21510 
 
21511 
 
21512 
  def __repr__(self):
21513 
    L = ['%s=%r' % (key, value)
21514 
      for key, value in self.__dict__.iteritems()]
21515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21516 
 
21517 
  def __eq__(self, other):
21518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21519 
 
21520 
  def __ne__(self, other):
21521 
    return not (self == other)
7770 kshitij.so 21522 
 
21523 
class updateTimestampForAmazonFeeds_args:
21524 
  """
21525 
  Attributes:
21526 
   - type
21527 
   - sku
21528 
   - timestamp
21529 
  """
21530 
 
21531 
  thrift_spec = (
21532 
    None, # 0
21533 
    (1, TType.STRING, 'type', None, None, ), # 1
21534 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21535 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21536 
  )
21537 
 
21538 
  def __init__(self, type=None, sku=None, timestamp=None,):
21539 
    self.type = type
21540 
    self.sku = sku
21541 
    self.timestamp = timestamp
21542 
 
21543 
  def read(self, iprot):
21544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21546 
      return
21547 
    iprot.readStructBegin()
21548 
    while True:
21549 
      (fname, ftype, fid) = iprot.readFieldBegin()
21550 
      if ftype == TType.STOP:
21551 
        break
21552 
      if fid == 1:
21553 
        if ftype == TType.STRING:
21554 
          self.type = iprot.readString();
21555 
        else:
21556 
          iprot.skip(ftype)
21557 
      elif fid == 2:
21558 
        if ftype == TType.LIST:
21559 
          self.sku = []
9155 kshitij.so 21560 
          (_etype463, _size460) = iprot.readListBegin()
21561 
          for _i464 in xrange(_size460):
21562 
            _elem465 = iprot.readI64();
21563 
            self.sku.append(_elem465)
7770 kshitij.so 21564 
          iprot.readListEnd()
21565 
        else:
21566 
          iprot.skip(ftype)
21567 
      elif fid == 3:
21568 
        if ftype == TType.I64:
21569 
          self.timestamp = iprot.readI64();
21570 
        else:
21571 
          iprot.skip(ftype)
21572 
      else:
21573 
        iprot.skip(ftype)
21574 
      iprot.readFieldEnd()
21575 
    iprot.readStructEnd()
21576 
 
21577 
  def write(self, oprot):
21578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21580 
      return
21581 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21582 
    if self.type is not None:
21583 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21584 
      oprot.writeString(self.type)
21585 
      oprot.writeFieldEnd()
21586 
    if self.sku is not None:
21587 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21588 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21589 
      for iter466 in self.sku:
21590 
        oprot.writeI64(iter466)
7770 kshitij.so 21591 
      oprot.writeListEnd()
21592 
      oprot.writeFieldEnd()
21593 
    if self.timestamp is not None:
21594 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21595 
      oprot.writeI64(self.timestamp)
21596 
      oprot.writeFieldEnd()
21597 
    oprot.writeFieldStop()
21598 
    oprot.writeStructEnd()
21599 
 
21600 
  def validate(self):
21601 
    return
21602 
 
21603 
 
21604 
  def __repr__(self):
21605 
    L = ['%s=%r' % (key, value)
21606 
      for key, value in self.__dict__.iteritems()]
21607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21608 
 
21609 
  def __eq__(self, other):
21610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21611 
 
21612 
  def __ne__(self, other):
21613 
    return not (self == other)
21614 
 
21615 
class updateTimestampForAmazonFeeds_result:
21616 
  """
21617 
  Attributes:
21618 
   - success
21619 
  """
21620 
 
21621 
  thrift_spec = (
21622 
    (0, TType.BOOL, 'success', None, None, ), # 0
21623 
  )
21624 
 
21625 
  def __init__(self, success=None,):
21626 
    self.success = success
21627 
 
21628 
  def read(self, iprot):
21629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21631 
      return
21632 
    iprot.readStructBegin()
21633 
    while True:
21634 
      (fname, ftype, fid) = iprot.readFieldBegin()
21635 
      if ftype == TType.STOP:
21636 
        break
21637 
      if fid == 0:
21638 
        if ftype == TType.BOOL:
21639 
          self.success = iprot.readBool();
21640 
        else:
21641 
          iprot.skip(ftype)
21642 
      else:
21643 
        iprot.skip(ftype)
21644 
      iprot.readFieldEnd()
21645 
    iprot.readStructEnd()
21646 
 
21647 
  def write(self, oprot):
21648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21650 
      return
21651 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21652 
    if self.success is not None:
21653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21654 
      oprot.writeBool(self.success)
21655 
      oprot.writeFieldEnd()
21656 
    oprot.writeFieldStop()
21657 
    oprot.writeStructEnd()
21658 
 
21659 
  def validate(self):
21660 
    return
21661 
 
21662 
 
21663 
  def __repr__(self):
21664 
    L = ['%s=%r' % (key, value)
21665 
      for key, value in self.__dict__.iteritems()]
21666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21667 
 
21668 
  def __eq__(self, other):
21669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21670 
 
21671 
  def __ne__(self, other):
21672 
    return not (self == other)
7897 amar.kumar 21673 
 
21674 
class getAllParentCategories_args:
21675 
 
21676 
  thrift_spec = (
21677 
  )
21678 
 
21679 
  def read(self, iprot):
21680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21682 
      return
21683 
    iprot.readStructBegin()
21684 
    while True:
21685 
      (fname, ftype, fid) = iprot.readFieldBegin()
21686 
      if ftype == TType.STOP:
21687 
        break
21688 
      else:
21689 
        iprot.skip(ftype)
21690 
      iprot.readFieldEnd()
21691 
    iprot.readStructEnd()
21692 
 
21693 
  def write(self, oprot):
21694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21696 
      return
21697 
    oprot.writeStructBegin('getAllParentCategories_args')
21698 
    oprot.writeFieldStop()
21699 
    oprot.writeStructEnd()
21700 
 
21701 
  def validate(self):
21702 
    return
21703 
 
21704 
 
21705 
  def __repr__(self):
21706 
    L = ['%s=%r' % (key, value)
21707 
      for key, value in self.__dict__.iteritems()]
21708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21709 
 
21710 
  def __eq__(self, other):
21711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21712 
 
21713 
  def __ne__(self, other):
21714 
    return not (self == other)
21715 
 
21716 
class getAllParentCategories_result:
21717 
  """
21718 
  Attributes:
21719 
   - success
21720 
  """
21721 
 
21722 
  thrift_spec = (
21723 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21724 
  )
21725 
 
21726 
  def __init__(self, success=None,):
21727 
    self.success = success
21728 
 
21729 
  def read(self, iprot):
21730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21732 
      return
21733 
    iprot.readStructBegin()
21734 
    while True:
21735 
      (fname, ftype, fid) = iprot.readFieldBegin()
21736 
      if ftype == TType.STOP:
21737 
        break
21738 
      if fid == 0:
21739 
        if ftype == TType.LIST:
21740 
          self.success = []
9155 kshitij.so 21741 
          (_etype470, _size467) = iprot.readListBegin()
21742 
          for _i471 in xrange(_size467):
21743 
            _elem472 = Category()
21744 
            _elem472.read(iprot)
21745 
            self.success.append(_elem472)
7897 amar.kumar 21746 
          iprot.readListEnd()
21747 
        else:
21748 
          iprot.skip(ftype)
21749 
      else:
21750 
        iprot.skip(ftype)
21751 
      iprot.readFieldEnd()
21752 
    iprot.readStructEnd()
21753 
 
21754 
  def write(self, oprot):
21755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21757 
      return
21758 
    oprot.writeStructBegin('getAllParentCategories_result')
21759 
    if self.success is not None:
21760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21761 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21762 
      for iter473 in self.success:
21763 
        iter473.write(oprot)
7897 amar.kumar 21764 
      oprot.writeListEnd()
21765 
      oprot.writeFieldEnd()
21766 
    oprot.writeFieldStop()
21767 
    oprot.writeStructEnd()
21768 
 
21769 
  def validate(self):
21770 
    return
21771 
 
21772 
 
21773 
  def __repr__(self):
21774 
    L = ['%s=%r' % (key, value)
21775 
      for key, value in self.__dict__.iteritems()]
21776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21777 
 
21778 
  def __eq__(self, other):
21779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21780 
 
21781 
  def __ne__(self, other):
21782 
    return not (self == other)
7977 kshitij.so 21783 
 
21784 
class addPageViewEvent_args:
21785 
  """
21786 
  Attributes:
21787 
   - pageViewEvents
21788 
  """
21789 
 
21790 
  thrift_spec = (
21791 
    None, # 0
21792 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21793 
  )
21794 
 
21795 
  def __init__(self, pageViewEvents=None,):
21796 
    self.pageViewEvents = pageViewEvents
21797 
 
21798 
  def read(self, iprot):
21799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21801 
      return
21802 
    iprot.readStructBegin()
21803 
    while True:
21804 
      (fname, ftype, fid) = iprot.readFieldBegin()
21805 
      if ftype == TType.STOP:
21806 
        break
21807 
      if fid == 1:
21808 
        if ftype == TType.STRUCT:
21809 
          self.pageViewEvents = PageViewEvents()
21810 
          self.pageViewEvents.read(iprot)
21811 
        else:
21812 
          iprot.skip(ftype)
21813 
      else:
21814 
        iprot.skip(ftype)
21815 
      iprot.readFieldEnd()
21816 
    iprot.readStructEnd()
21817 
 
21818 
  def write(self, oprot):
21819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21821 
      return
21822 
    oprot.writeStructBegin('addPageViewEvent_args')
21823 
    if self.pageViewEvents is not None:
21824 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21825 
      self.pageViewEvents.write(oprot)
21826 
      oprot.writeFieldEnd()
21827 
    oprot.writeFieldStop()
21828 
    oprot.writeStructEnd()
21829 
 
21830 
  def validate(self):
21831 
    return
21832 
 
21833 
 
21834 
  def __repr__(self):
21835 
    L = ['%s=%r' % (key, value)
21836 
      for key, value in self.__dict__.iteritems()]
21837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21838 
 
21839 
  def __eq__(self, other):
21840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21841 
 
21842 
  def __ne__(self, other):
21843 
    return not (self == other)
21844 
 
21845 
class addPageViewEvent_result:
21846 
 
21847 
  thrift_spec = (
21848 
  )
21849 
 
21850 
  def read(self, iprot):
21851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21853 
      return
21854 
    iprot.readStructBegin()
21855 
    while True:
21856 
      (fname, ftype, fid) = iprot.readFieldBegin()
21857 
      if ftype == TType.STOP:
21858 
        break
21859 
      else:
21860 
        iprot.skip(ftype)
21861 
      iprot.readFieldEnd()
21862 
    iprot.readStructEnd()
21863 
 
21864 
  def write(self, oprot):
21865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21867 
      return
21868 
    oprot.writeStructBegin('addPageViewEvent_result')
21869 
    oprot.writeFieldStop()
21870 
    oprot.writeStructEnd()
21871 
 
21872 
  def validate(self):
21873 
    return
21874 
 
21875 
 
21876 
  def __repr__(self):
21877 
    L = ['%s=%r' % (key, value)
21878 
      for key, value in self.__dict__.iteritems()]
21879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21880 
 
21881 
  def __eq__(self, other):
21882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21883 
 
21884 
  def __ne__(self, other):
21885 
    return not (self == other)
21886 
 
21887 
class addCartEvent_args:
21888 
  """
21889 
  Attributes:
21890 
   - cartEvents
21891 
  """
21892 
 
21893 
  thrift_spec = (
21894 
    None, # 0
21895 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21896 
  )
21897 
 
21898 
  def __init__(self, cartEvents=None,):
21899 
    self.cartEvents = cartEvents
21900 
 
21901 
  def read(self, iprot):
21902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21904 
      return
21905 
    iprot.readStructBegin()
21906 
    while True:
21907 
      (fname, ftype, fid) = iprot.readFieldBegin()
21908 
      if ftype == TType.STOP:
21909 
        break
21910 
      if fid == 1:
21911 
        if ftype == TType.STRUCT:
21912 
          self.cartEvents = CartEvents()
21913 
          self.cartEvents.read(iprot)
21914 
        else:
21915 
          iprot.skip(ftype)
21916 
      else:
21917 
        iprot.skip(ftype)
21918 
      iprot.readFieldEnd()
21919 
    iprot.readStructEnd()
21920 
 
21921 
  def write(self, oprot):
21922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21924 
      return
21925 
    oprot.writeStructBegin('addCartEvent_args')
21926 
    if self.cartEvents is not None:
21927 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21928 
      self.cartEvents.write(oprot)
21929 
      oprot.writeFieldEnd()
21930 
    oprot.writeFieldStop()
21931 
    oprot.writeStructEnd()
21932 
 
21933 
  def validate(self):
21934 
    return
21935 
 
21936 
 
21937 
  def __repr__(self):
21938 
    L = ['%s=%r' % (key, value)
21939 
      for key, value in self.__dict__.iteritems()]
21940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21941 
 
21942 
  def __eq__(self, other):
21943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21944 
 
21945 
  def __ne__(self, other):
21946 
    return not (self == other)
21947 
 
21948 
class addCartEvent_result:
21949 
 
21950 
  thrift_spec = (
21951 
  )
21952 
 
21953 
  def read(self, iprot):
21954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21956 
      return
21957 
    iprot.readStructBegin()
21958 
    while True:
21959 
      (fname, ftype, fid) = iprot.readFieldBegin()
21960 
      if ftype == TType.STOP:
21961 
        break
21962 
      else:
21963 
        iprot.skip(ftype)
21964 
      iprot.readFieldEnd()
21965 
    iprot.readStructEnd()
21966 
 
21967 
  def write(self, oprot):
21968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21970 
      return
21971 
    oprot.writeStructBegin('addCartEvent_result')
21972 
    oprot.writeFieldStop()
21973 
    oprot.writeStructEnd()
21974 
 
21975 
  def validate(self):
21976 
    return
21977 
 
21978 
 
21979 
  def __repr__(self):
21980 
    L = ['%s=%r' % (key, value)
21981 
      for key, value in self.__dict__.iteritems()]
21982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21983 
 
21984 
  def __eq__(self, other):
21985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21986 
 
21987 
  def __ne__(self, other):
21988 
    return not (self == other)
8139 kshitij.so 21989 
 
8182 amar.kumar 21990 
class addEbayItem_args:
21991 
  """
21992 
  Attributes:
21993 
   - ebayItem
21994 
  """
21995 
 
21996 
  thrift_spec = (
21997 
    None, # 0
21998 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21999 
  )
22000 
 
22001 
  def __init__(self, ebayItem=None,):
22002 
    self.ebayItem = ebayItem
22003 
 
22004 
  def read(self, iprot):
22005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22007 
      return
22008 
    iprot.readStructBegin()
22009 
    while True:
22010 
      (fname, ftype, fid) = iprot.readFieldBegin()
22011 
      if ftype == TType.STOP:
22012 
        break
22013 
      if fid == 1:
22014 
        if ftype == TType.STRUCT:
22015 
          self.ebayItem = EbayItem()
22016 
          self.ebayItem.read(iprot)
22017 
        else:
22018 
          iprot.skip(ftype)
22019 
      else:
22020 
        iprot.skip(ftype)
22021 
      iprot.readFieldEnd()
22022 
    iprot.readStructEnd()
22023 
 
22024 
  def write(self, oprot):
22025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22027 
      return
22028 
    oprot.writeStructBegin('addEbayItem_args')
22029 
    if self.ebayItem is not None:
22030 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22031 
      self.ebayItem.write(oprot)
22032 
      oprot.writeFieldEnd()
22033 
    oprot.writeFieldStop()
22034 
    oprot.writeStructEnd()
22035 
 
22036 
  def validate(self):
22037 
    return
22038 
 
22039 
 
22040 
  def __repr__(self):
22041 
    L = ['%s=%r' % (key, value)
22042 
      for key, value in self.__dict__.iteritems()]
22043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22044 
 
22045 
  def __eq__(self, other):
22046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22047 
 
22048 
  def __ne__(self, other):
22049 
    return not (self == other)
22050 
 
22051 
class addEbayItem_result:
22052 
 
22053 
  thrift_spec = (
22054 
  )
22055 
 
22056 
  def read(self, iprot):
22057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22059 
      return
22060 
    iprot.readStructBegin()
22061 
    while True:
22062 
      (fname, ftype, fid) = iprot.readFieldBegin()
22063 
      if ftype == TType.STOP:
22064 
        break
22065 
      else:
22066 
        iprot.skip(ftype)
22067 
      iprot.readFieldEnd()
22068 
    iprot.readStructEnd()
22069 
 
22070 
  def write(self, oprot):
22071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22073 
      return
22074 
    oprot.writeStructBegin('addEbayItem_result')
22075 
    oprot.writeFieldStop()
22076 
    oprot.writeStructEnd()
22077 
 
22078 
  def validate(self):
22079 
    return
22080 
 
22081 
 
22082 
  def __repr__(self):
22083 
    L = ['%s=%r' % (key, value)
22084 
      for key, value in self.__dict__.iteritems()]
22085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22086 
 
22087 
  def __eq__(self, other):
22088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22089 
 
22090 
  def __ne__(self, other):
22091 
    return not (self == other)
22092 
 
22093 
class getEbayItem_args:
22094 
  """
22095 
  Attributes:
22096 
   - listingId
22097 
  """
22098 
 
22099 
  thrift_spec = (
22100 
    None, # 0
22101 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22102 
  )
22103 
 
22104 
  def __init__(self, listingId=None,):
22105 
    self.listingId = listingId
22106 
 
22107 
  def read(self, iprot):
22108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22110 
      return
22111 
    iprot.readStructBegin()
22112 
    while True:
22113 
      (fname, ftype, fid) = iprot.readFieldBegin()
22114 
      if ftype == TType.STOP:
22115 
        break
22116 
      if fid == 1:
22117 
        if ftype == TType.STRING:
22118 
          self.listingId = iprot.readString();
22119 
        else:
22120 
          iprot.skip(ftype)
22121 
      else:
22122 
        iprot.skip(ftype)
22123 
      iprot.readFieldEnd()
22124 
    iprot.readStructEnd()
22125 
 
22126 
  def write(self, oprot):
22127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22129 
      return
22130 
    oprot.writeStructBegin('getEbayItem_args')
22131 
    if self.listingId is not None:
22132 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22133 
      oprot.writeString(self.listingId)
22134 
      oprot.writeFieldEnd()
22135 
    oprot.writeFieldStop()
22136 
    oprot.writeStructEnd()
22137 
 
22138 
  def validate(self):
22139 
    return
22140 
 
22141 
 
22142 
  def __repr__(self):
22143 
    L = ['%s=%r' % (key, value)
22144 
      for key, value in self.__dict__.iteritems()]
22145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22146 
 
22147 
  def __eq__(self, other):
22148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22149 
 
22150 
  def __ne__(self, other):
22151 
    return not (self == other)
22152 
 
22153 
class getEbayItem_result:
22154 
  """
22155 
  Attributes:
22156 
   - success
22157 
  """
22158 
 
22159 
  thrift_spec = (
22160 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22161 
  )
22162 
 
22163 
  def __init__(self, success=None,):
22164 
    self.success = success
22165 
 
22166 
  def read(self, iprot):
22167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22169 
      return
22170 
    iprot.readStructBegin()
22171 
    while True:
22172 
      (fname, ftype, fid) = iprot.readFieldBegin()
22173 
      if ftype == TType.STOP:
22174 
        break
22175 
      if fid == 0:
22176 
        if ftype == TType.STRUCT:
22177 
          self.success = EbayItem()
22178 
          self.success.read(iprot)
22179 
        else:
22180 
          iprot.skip(ftype)
22181 
      else:
22182 
        iprot.skip(ftype)
22183 
      iprot.readFieldEnd()
22184 
    iprot.readStructEnd()
22185 
 
22186 
  def write(self, oprot):
22187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22189 
      return
22190 
    oprot.writeStructBegin('getEbayItem_result')
22191 
    if self.success is not None:
22192 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22193 
      self.success.write(oprot)
22194 
      oprot.writeFieldEnd()
22195 
    oprot.writeFieldStop()
22196 
    oprot.writeStructEnd()
22197 
 
22198 
  def validate(self):
22199 
    return
22200 
 
22201 
 
22202 
  def __repr__(self):
22203 
    L = ['%s=%r' % (key, value)
22204 
      for key, value in self.__dict__.iteritems()]
22205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22206 
 
22207 
  def __eq__(self, other):
22208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22209 
 
22210 
  def __ne__(self, other):
22211 
    return not (self == other)
22212 
 
22213 
class updateEbayItem_args:
22214 
  """
22215 
  Attributes:
22216 
   - ebayItem
22217 
  """
22218 
 
22219 
  thrift_spec = (
22220 
    None, # 0
22221 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22222 
  )
22223 
 
22224 
  def __init__(self, ebayItem=None,):
22225 
    self.ebayItem = ebayItem
22226 
 
22227 
  def read(self, iprot):
22228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22230 
      return
22231 
    iprot.readStructBegin()
22232 
    while True:
22233 
      (fname, ftype, fid) = iprot.readFieldBegin()
22234 
      if ftype == TType.STOP:
22235 
        break
22236 
      if fid == 1:
22237 
        if ftype == TType.STRUCT:
22238 
          self.ebayItem = EbayItem()
22239 
          self.ebayItem.read(iprot)
22240 
        else:
22241 
          iprot.skip(ftype)
22242 
      else:
22243 
        iprot.skip(ftype)
22244 
      iprot.readFieldEnd()
22245 
    iprot.readStructEnd()
22246 
 
22247 
  def write(self, oprot):
22248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22250 
      return
22251 
    oprot.writeStructBegin('updateEbayItem_args')
22252 
    if self.ebayItem is not None:
22253 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22254 
      self.ebayItem.write(oprot)
22255 
      oprot.writeFieldEnd()
22256 
    oprot.writeFieldStop()
22257 
    oprot.writeStructEnd()
22258 
 
22259 
  def validate(self):
22260 
    return
22261 
 
22262 
 
22263 
  def __repr__(self):
22264 
    L = ['%s=%r' % (key, value)
22265 
      for key, value in self.__dict__.iteritems()]
22266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22267 
 
22268 
  def __eq__(self, other):
22269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22270 
 
22271 
  def __ne__(self, other):
22272 
    return not (self == other)
22273 
 
22274 
class updateEbayItem_result:
22275 
 
22276 
  thrift_spec = (
22277 
  )
22278 
 
22279 
  def read(self, iprot):
22280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22282 
      return
22283 
    iprot.readStructBegin()
22284 
    while True:
22285 
      (fname, ftype, fid) = iprot.readFieldBegin()
22286 
      if ftype == TType.STOP:
22287 
        break
22288 
      else:
22289 
        iprot.skip(ftype)
22290 
      iprot.readFieldEnd()
22291 
    iprot.readStructEnd()
22292 
 
22293 
  def write(self, oprot):
22294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22296 
      return
22297 
    oprot.writeStructBegin('updateEbayItem_result')
22298 
    oprot.writeFieldStop()
22299 
    oprot.writeStructEnd()
22300 
 
22301 
  def validate(self):
22302 
    return
22303 
 
22304 
 
22305 
  def __repr__(self):
22306 
    L = ['%s=%r' % (key, value)
22307 
      for key, value in self.__dict__.iteritems()]
22308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22309 
 
22310 
  def __eq__(self, other):
22311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22312 
 
22313 
  def __ne__(self, other):
22314 
    return not (self == other)
22315 
 
8139 kshitij.so 22316 
class getAmazonListedItems_args:
22317 
  """
22318 
  Attributes:
22319 
   - offset
22320 
   - limit
22321 
  """
22322 
 
22323 
  thrift_spec = (
22324 
    None, # 0
22325 
    (1, TType.I64, 'offset', None, None, ), # 1
22326 
    (2, TType.I64, 'limit', None, None, ), # 2
22327 
  )
22328 
 
22329 
  def __init__(self, offset=None, limit=None,):
22330 
    self.offset = offset
22331 
    self.limit = limit
22332 
 
22333 
  def read(self, iprot):
22334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22336 
      return
22337 
    iprot.readStructBegin()
22338 
    while True:
22339 
      (fname, ftype, fid) = iprot.readFieldBegin()
22340 
      if ftype == TType.STOP:
22341 
        break
22342 
      if fid == 1:
22343 
        if ftype == TType.I64:
22344 
          self.offset = iprot.readI64();
22345 
        else:
22346 
          iprot.skip(ftype)
22347 
      elif fid == 2:
22348 
        if ftype == TType.I64:
22349 
          self.limit = iprot.readI64();
22350 
        else:
22351 
          iprot.skip(ftype)
22352 
      else:
22353 
        iprot.skip(ftype)
22354 
      iprot.readFieldEnd()
22355 
    iprot.readStructEnd()
22356 
 
22357 
  def write(self, oprot):
22358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22360 
      return
22361 
    oprot.writeStructBegin('getAmazonListedItems_args')
22362 
    if self.offset is not None:
22363 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22364 
      oprot.writeI64(self.offset)
22365 
      oprot.writeFieldEnd()
22366 
    if self.limit is not None:
22367 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22368 
      oprot.writeI64(self.limit)
22369 
      oprot.writeFieldEnd()
22370 
    oprot.writeFieldStop()
22371 
    oprot.writeStructEnd()
22372 
 
22373 
  def validate(self):
22374 
    return
22375 
 
22376 
 
22377 
  def __repr__(self):
22378 
    L = ['%s=%r' % (key, value)
22379 
      for key, value in self.__dict__.iteritems()]
22380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22381 
 
22382 
  def __eq__(self, other):
22383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22384 
 
22385 
  def __ne__(self, other):
22386 
    return not (self == other)
22387 
 
22388 
class getAmazonListedItems_result:
22389 
  """
22390 
  Attributes:
22391 
   - success
22392 
  """
22393 
 
22394 
  thrift_spec = (
22395 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22396 
  )
22397 
 
22398 
  def __init__(self, success=None,):
22399 
    self.success = success
22400 
 
22401 
  def read(self, iprot):
22402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22404 
      return
22405 
    iprot.readStructBegin()
22406 
    while True:
22407 
      (fname, ftype, fid) = iprot.readFieldBegin()
22408 
      if ftype == TType.STOP:
22409 
        break
22410 
      if fid == 0:
22411 
        if ftype == TType.LIST:
22412 
          self.success = []
9155 kshitij.so 22413 
          (_etype477, _size474) = iprot.readListBegin()
22414 
          for _i478 in xrange(_size474):
22415 
            _elem479 = Amazonlisted()
22416 
            _elem479.read(iprot)
22417 
            self.success.append(_elem479)
8139 kshitij.so 22418 
          iprot.readListEnd()
22419 
        else:
22420 
          iprot.skip(ftype)
22421 
      else:
22422 
        iprot.skip(ftype)
22423 
      iprot.readFieldEnd()
22424 
    iprot.readStructEnd()
22425 
 
22426 
  def write(self, oprot):
22427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22429 
      return
22430 
    oprot.writeStructBegin('getAmazonListedItems_result')
22431 
    if self.success is not None:
22432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22434 
      for iter480 in self.success:
22435 
        iter480.write(oprot)
8139 kshitij.so 22436 
      oprot.writeListEnd()
22437 
      oprot.writeFieldEnd()
22438 
    oprot.writeFieldStop()
22439 
    oprot.writeStructEnd()
22440 
 
22441 
  def validate(self):
22442 
    return
22443 
 
22444 
 
22445 
  def __repr__(self):
22446 
    L = ['%s=%r' % (key, value)
22447 
      for key, value in self.__dict__.iteritems()]
22448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22449 
 
22450 
  def __eq__(self, other):
22451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22452 
 
22453 
  def __ne__(self, other):
22454 
    return not (self == other)
8168 kshitij.so 22455 
 
22456 
class updateAmazonAttributesInBulk_args:
22457 
  """
22458 
  Attributes:
22459 
   - amazonlisted
22460 
  """
22461 
 
22462 
  thrift_spec = (
22463 
    None, # 0
22464 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22465 
  )
22466 
 
22467 
  def __init__(self, amazonlisted=None,):
22468 
    self.amazonlisted = amazonlisted
22469 
 
22470 
  def read(self, iprot):
22471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22473 
      return
22474 
    iprot.readStructBegin()
22475 
    while True:
22476 
      (fname, ftype, fid) = iprot.readFieldBegin()
22477 
      if ftype == TType.STOP:
22478 
        break
22479 
      if fid == 1:
22480 
        if ftype == TType.MAP:
22481 
          self.amazonlisted = {}
9155 kshitij.so 22482 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22483 
          for _i485 in xrange(_size481):
22484 
            _key486 = iprot.readI64();
22485 
            _val487 = Amazonlisted()
22486 
            _val487.read(iprot)
22487 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22488 
          iprot.readMapEnd()
22489 
        else:
22490 
          iprot.skip(ftype)
22491 
      else:
22492 
        iprot.skip(ftype)
22493 
      iprot.readFieldEnd()
22494 
    iprot.readStructEnd()
22495 
 
22496 
  def write(self, oprot):
22497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22499 
      return
22500 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22501 
    if self.amazonlisted is not None:
22502 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22503 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22504 
      for kiter488,viter489 in self.amazonlisted.items():
22505 
        oprot.writeI64(kiter488)
22506 
        viter489.write(oprot)
8168 kshitij.so 22507 
      oprot.writeMapEnd()
22508 
      oprot.writeFieldEnd()
22509 
    oprot.writeFieldStop()
22510 
    oprot.writeStructEnd()
22511 
 
22512 
  def validate(self):
22513 
    return
22514 
 
22515 
 
22516 
  def __repr__(self):
22517 
    L = ['%s=%r' % (key, value)
22518 
      for key, value in self.__dict__.iteritems()]
22519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22520 
 
22521 
  def __eq__(self, other):
22522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22523 
 
22524 
  def __ne__(self, other):
22525 
    return not (self == other)
22526 
 
22527 
class updateAmazonAttributesInBulk_result:
22528 
  """
22529 
  Attributes:
22530 
   - success
22531 
  """
22532 
 
22533 
  thrift_spec = (
22534 
    (0, TType.BOOL, 'success', None, None, ), # 0
22535 
  )
22536 
 
22537 
  def __init__(self, success=None,):
22538 
    self.success = success
22539 
 
22540 
  def read(self, iprot):
22541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22543 
      return
22544 
    iprot.readStructBegin()
22545 
    while True:
22546 
      (fname, ftype, fid) = iprot.readFieldBegin()
22547 
      if ftype == TType.STOP:
22548 
        break
22549 
      if fid == 0:
22550 
        if ftype == TType.BOOL:
22551 
          self.success = iprot.readBool();
22552 
        else:
22553 
          iprot.skip(ftype)
22554 
      else:
22555 
        iprot.skip(ftype)
22556 
      iprot.readFieldEnd()
22557 
    iprot.readStructEnd()
22558 
 
22559 
  def write(self, oprot):
22560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22562 
      return
22563 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22564 
    if self.success is not None:
22565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22566 
      oprot.writeBool(self.success)
22567 
      oprot.writeFieldEnd()
22568 
    oprot.writeFieldStop()
22569 
    oprot.writeStructEnd()
22570 
 
22571 
  def validate(self):
22572 
    return
22573 
 
22574 
 
22575 
  def __repr__(self):
22576 
    L = ['%s=%r' % (key, value)
22577 
      for key, value in self.__dict__.iteritems()]
22578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22579 
 
22580 
  def __eq__(self, other):
22581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22582 
 
22583 
  def __ne__(self, other):
22584 
    return not (self == other)
8379 vikram.rag 22585 
 
22586 
class getAllItemstoListOnFba_args:
22587 
 
22588 
  thrift_spec = (
22589 
  )
22590 
 
22591 
  def read(self, iprot):
22592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22594 
      return
22595 
    iprot.readStructBegin()
22596 
    while True:
22597 
      (fname, ftype, fid) = iprot.readFieldBegin()
22598 
      if ftype == TType.STOP:
22599 
        break
22600 
      else:
22601 
        iprot.skip(ftype)
22602 
      iprot.readFieldEnd()
22603 
    iprot.readStructEnd()
22604 
 
22605 
  def write(self, oprot):
22606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22608 
      return
22609 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
22610 
    oprot.writeFieldStop()
22611 
    oprot.writeStructEnd()
22612 
 
22613 
  def validate(self):
22614 
    return
22615 
 
22616 
 
22617 
  def __repr__(self):
22618 
    L = ['%s=%r' % (key, value)
22619 
      for key, value in self.__dict__.iteritems()]
22620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22621 
 
22622 
  def __eq__(self, other):
22623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22624 
 
22625 
  def __ne__(self, other):
22626 
    return not (self == other)
22627 
 
22628 
class getAllItemstoListOnFba_result:
22629 
  """
22630 
  Attributes:
22631 
   - success
22632 
  """
22633 
 
22634 
  thrift_spec = (
22635 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22636 
  )
22637 
 
22638 
  def __init__(self, success=None,):
22639 
    self.success = success
22640 
 
22641 
  def read(self, iprot):
22642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22644 
      return
22645 
    iprot.readStructBegin()
22646 
    while True:
22647 
      (fname, ftype, fid) = iprot.readFieldBegin()
22648 
      if ftype == TType.STOP:
22649 
        break
22650 
      if fid == 0:
22651 
        if ftype == TType.LIST:
22652 
          self.success = []
9155 kshitij.so 22653 
          (_etype493, _size490) = iprot.readListBegin()
22654 
          for _i494 in xrange(_size490):
22655 
            _elem495 = Amazonlisted()
22656 
            _elem495.read(iprot)
22657 
            self.success.append(_elem495)
8379 vikram.rag 22658 
          iprot.readListEnd()
22659 
        else:
22660 
          iprot.skip(ftype)
22661 
      else:
22662 
        iprot.skip(ftype)
22663 
      iprot.readFieldEnd()
22664 
    iprot.readStructEnd()
22665 
 
22666 
  def write(self, oprot):
22667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22669 
      return
22670 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22671 
    if self.success is not None:
22672 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22673 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22674 
      for iter496 in self.success:
22675 
        iter496.write(oprot)
8379 vikram.rag 22676 
      oprot.writeListEnd()
22677 
      oprot.writeFieldEnd()
22678 
    oprot.writeFieldStop()
22679 
    oprot.writeStructEnd()
22680 
 
22681 
  def validate(self):
22682 
    return
22683 
 
22684 
 
22685 
  def __repr__(self):
22686 
    L = ['%s=%r' % (key, value)
22687 
      for key, value in self.__dict__.iteritems()]
22688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22689 
 
22690 
  def __eq__(self, other):
22691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22692 
 
22693 
  def __ne__(self, other):
22694 
    return not (self == other)
22695 
 
22696 
class getAllItemstoListOnNonFba_args:
22697 
 
22698 
  thrift_spec = (
22699 
  )
22700 
 
22701 
  def read(self, iprot):
22702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22704 
      return
22705 
    iprot.readStructBegin()
22706 
    while True:
22707 
      (fname, ftype, fid) = iprot.readFieldBegin()
22708 
      if ftype == TType.STOP:
22709 
        break
22710 
      else:
22711 
        iprot.skip(ftype)
22712 
      iprot.readFieldEnd()
22713 
    iprot.readStructEnd()
22714 
 
22715 
  def write(self, oprot):
22716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22718 
      return
22719 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22720 
    oprot.writeFieldStop()
22721 
    oprot.writeStructEnd()
22722 
 
22723 
  def validate(self):
22724 
    return
22725 
 
22726 
 
22727 
  def __repr__(self):
22728 
    L = ['%s=%r' % (key, value)
22729 
      for key, value in self.__dict__.iteritems()]
22730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22731 
 
22732 
  def __eq__(self, other):
22733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22734 
 
22735 
  def __ne__(self, other):
22736 
    return not (self == other)
22737 
 
22738 
class getAllItemstoListOnNonFba_result:
22739 
  """
22740 
  Attributes:
22741 
   - success
22742 
  """
22743 
 
22744 
  thrift_spec = (
22745 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22746 
  )
22747 
 
22748 
  def __init__(self, success=None,):
22749 
    self.success = success
22750 
 
22751 
  def read(self, iprot):
22752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22754 
      return
22755 
    iprot.readStructBegin()
22756 
    while True:
22757 
      (fname, ftype, fid) = iprot.readFieldBegin()
22758 
      if ftype == TType.STOP:
22759 
        break
22760 
      if fid == 0:
22761 
        if ftype == TType.LIST:
22762 
          self.success = []
9155 kshitij.so 22763 
          (_etype500, _size497) = iprot.readListBegin()
22764 
          for _i501 in xrange(_size497):
22765 
            _elem502 = Amazonlisted()
22766 
            _elem502.read(iprot)
22767 
            self.success.append(_elem502)
8379 vikram.rag 22768 
          iprot.readListEnd()
22769 
        else:
22770 
          iprot.skip(ftype)
22771 
      else:
22772 
        iprot.skip(ftype)
22773 
      iprot.readFieldEnd()
22774 
    iprot.readStructEnd()
22775 
 
22776 
  def write(self, oprot):
22777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22779 
      return
22780 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22781 
    if self.success is not None:
22782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22784 
      for iter503 in self.success:
22785 
        iter503.write(oprot)
8379 vikram.rag 22786 
      oprot.writeListEnd()
22787 
      oprot.writeFieldEnd()
22788 
    oprot.writeFieldStop()
22789 
    oprot.writeStructEnd()
22790 
 
22791 
  def validate(self):
22792 
    return
22793 
 
22794 
 
22795 
  def __repr__(self):
22796 
    L = ['%s=%r' % (key, value)
22797 
      for key, value in self.__dict__.iteritems()]
22798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22799 
 
22800 
  def __eq__(self, other):
22801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22802 
 
22803 
  def __ne__(self, other):
22804 
    return not (self == other)
8616 vikram.rag 22805 
 
9242 kshitij.so 22806 
class updateAsin_args:
22807 
  """
22808 
  Attributes:
22809 
   - item
22810 
  """
8616 vikram.rag 22811 
 
22812 
  thrift_spec = (
9242 kshitij.so 22813 
    None, # 0
22814 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22815 
  )
22816 
 
9242 kshitij.so 22817 
  def __init__(self, item=None,):
22818 
    self.item = item
22819 
 
8616 vikram.rag 22820 
  def read(self, iprot):
22821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22823 
      return
22824 
    iprot.readStructBegin()
22825 
    while True:
22826 
      (fname, ftype, fid) = iprot.readFieldBegin()
22827 
      if ftype == TType.STOP:
22828 
        break
9242 kshitij.so 22829 
      if fid == 1:
22830 
        if ftype == TType.MAP:
22831 
          self.item = {}
22832 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22833 
          for _i508 in xrange(_size504):
22834 
            _key509 = iprot.readI64();
22835 
            _val510 = Item()
22836 
            _val510.read(iprot)
22837 
            self.item[_key509] = _val510
22838 
          iprot.readMapEnd()
22839 
        else:
22840 
          iprot.skip(ftype)
8616 vikram.rag 22841 
      else:
22842 
        iprot.skip(ftype)
22843 
      iprot.readFieldEnd()
22844 
    iprot.readStructEnd()
22845 
 
22846 
  def write(self, oprot):
22847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22849 
      return
9242 kshitij.so 22850 
    oprot.writeStructBegin('updateAsin_args')
22851 
    if self.item is not None:
22852 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22853 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22854 
      for kiter511,viter512 in self.item.items():
22855 
        oprot.writeI64(kiter511)
22856 
        viter512.write(oprot)
22857 
      oprot.writeMapEnd()
22858 
      oprot.writeFieldEnd()
8616 vikram.rag 22859 
    oprot.writeFieldStop()
22860 
    oprot.writeStructEnd()
22861 
 
22862 
  def validate(self):
22863 
    return
22864 
 
22865 
 
22866 
  def __repr__(self):
22867 
    L = ['%s=%r' % (key, value)
22868 
      for key, value in self.__dict__.iteritems()]
22869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22870 
 
22871 
  def __eq__(self, other):
22872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22873 
 
22874 
  def __ne__(self, other):
22875 
    return not (self == other)
22876 
 
9242 kshitij.so 22877 
class updateAsin_result:
8616 vikram.rag 22878 
 
22879 
  thrift_spec = (
22880 
  )
22881 
 
22882 
  def read(self, iprot):
22883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22885 
      return
22886 
    iprot.readStructBegin()
22887 
    while True:
22888 
      (fname, ftype, fid) = iprot.readFieldBegin()
22889 
      if ftype == TType.STOP:
22890 
        break
22891 
      else:
22892 
        iprot.skip(ftype)
22893 
      iprot.readFieldEnd()
22894 
    iprot.readStructEnd()
22895 
 
22896 
  def write(self, oprot):
22897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22899 
      return
9242 kshitij.so 22900 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22901 
    oprot.writeFieldStop()
22902 
    oprot.writeStructEnd()
22903 
 
22904 
  def validate(self):
22905 
    return
22906 
 
22907 
 
22908 
  def __repr__(self):
22909 
    L = ['%s=%r' % (key, value)
22910 
      for key, value in self.__dict__.iteritems()]
22911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22912 
 
22913 
  def __eq__(self, other):
22914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22915 
 
22916 
  def __ne__(self, other):
22917 
    return not (self == other)
8619 kshitij.so 22918 
 
9242 kshitij.so 22919 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22920 
  """
22921 
  Attributes:
9242 kshitij.so 22922 
   - snapdealitem
8619 kshitij.so 22923 
  """
22924 
 
9242 kshitij.so 22925 
  thrift_spec = None
22926 
  def __init__(self, snapdealitem=None,):
22927 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22928 
 
22929 
  def read(self, iprot):
22930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22932 
      return
22933 
    iprot.readStructBegin()
22934 
    while True:
22935 
      (fname, ftype, fid) = iprot.readFieldBegin()
22936 
      if ftype == TType.STOP:
22937 
        break
9242 kshitij.so 22938 
      if fid == -1:
22939 
        if ftype == TType.STRUCT:
22940 
          self.snapdealitem = SnapdealItem()
22941 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22942 
        else:
22943 
          iprot.skip(ftype)
22944 
      else:
22945 
        iprot.skip(ftype)
22946 
      iprot.readFieldEnd()
22947 
    iprot.readStructEnd()
22948 
 
22949 
  def write(self, oprot):
22950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22952 
      return
9242 kshitij.so 22953 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22954 
    if self.snapdealitem is not None:
22955 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22956 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22957 
      oprot.writeFieldEnd()
22958 
    oprot.writeFieldStop()
22959 
    oprot.writeStructEnd()
22960 
 
22961 
  def validate(self):
22962 
    return
22963 
 
22964 
 
22965 
  def __repr__(self):
22966 
    L = ['%s=%r' % (key, value)
22967 
      for key, value in self.__dict__.iteritems()]
22968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22969 
 
22970 
  def __eq__(self, other):
22971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22972 
 
22973 
  def __ne__(self, other):
22974 
    return not (self == other)
22975 
 
9242 kshitij.so 22976 
class addOrUpdateSnapdealItem_result:
22977 
  """
22978 
  Attributes:
22979 
   - success
22980 
  """
8619 kshitij.so 22981 
 
22982 
  thrift_spec = (
9242 kshitij.so 22983 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22984 
  )
22985 
 
9242 kshitij.so 22986 
  def __init__(self, success=None,):
22987 
    self.success = success
22988 
 
8619 kshitij.so 22989 
  def read(self, iprot):
22990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22992 
      return
22993 
    iprot.readStructBegin()
22994 
    while True:
22995 
      (fname, ftype, fid) = iprot.readFieldBegin()
22996 
      if ftype == TType.STOP:
22997 
        break
9242 kshitij.so 22998 
      if fid == 0:
22999 
        if ftype == TType.BOOL:
23000 
          self.success = iprot.readBool();
23001 
        else:
23002 
          iprot.skip(ftype)
8619 kshitij.so 23003 
      else:
23004 
        iprot.skip(ftype)
23005 
      iprot.readFieldEnd()
23006 
    iprot.readStructEnd()
23007 
 
23008 
  def write(self, oprot):
23009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23011 
      return
9242 kshitij.so 23012 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23013 
    if self.success is not None:
23014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23015 
      oprot.writeBool(self.success)
23016 
      oprot.writeFieldEnd()
8619 kshitij.so 23017 
    oprot.writeFieldStop()
23018 
    oprot.writeStructEnd()
23019 
 
23020 
  def validate(self):
23021 
    return
23022 
 
23023 
 
23024 
  def __repr__(self):
23025 
    L = ['%s=%r' % (key, value)
23026 
      for key, value in self.__dict__.iteritems()]
23027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23028 
 
23029 
  def __eq__(self, other):
23030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23031 
 
23032 
  def __ne__(self, other):
23033 
    return not (self == other)
8739 vikram.rag 23034 
 
9242 kshitij.so 23035 
class getSnapdealItem_args:
8739 vikram.rag 23036 
  """
23037 
  Attributes:
9242 kshitij.so 23038 
   - item_id
8739 vikram.rag 23039 
  """
23040 
 
9242 kshitij.so 23041 
  thrift_spec = (
23042 
    None, # 0
23043 
    (1, TType.I64, 'item_id', None, None, ), # 1
23044 
  )
8739 vikram.rag 23045 
 
9242 kshitij.so 23046 
  def __init__(self, item_id=None,):
23047 
    self.item_id = item_id
23048 
 
8739 vikram.rag 23049 
  def read(self, iprot):
23050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23052 
      return
23053 
    iprot.readStructBegin()
23054 
    while True:
23055 
      (fname, ftype, fid) = iprot.readFieldBegin()
23056 
      if ftype == TType.STOP:
23057 
        break
9242 kshitij.so 23058 
      if fid == 1:
23059 
        if ftype == TType.I64:
23060 
          self.item_id = iprot.readI64();
8739 vikram.rag 23061 
        else:
23062 
          iprot.skip(ftype)
23063 
      else:
23064 
        iprot.skip(ftype)
23065 
      iprot.readFieldEnd()
23066 
    iprot.readStructEnd()
23067 
 
23068 
  def write(self, oprot):
23069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23071 
      return
9242 kshitij.so 23072 
    oprot.writeStructBegin('getSnapdealItem_args')
23073 
    if self.item_id is not None:
23074 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23075 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23076 
      oprot.writeFieldEnd()
23077 
    oprot.writeFieldStop()
23078 
    oprot.writeStructEnd()
23079 
 
23080 
  def validate(self):
23081 
    return
23082 
 
23083 
 
23084 
  def __repr__(self):
23085 
    L = ['%s=%r' % (key, value)
23086 
      for key, value in self.__dict__.iteritems()]
23087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23088 
 
23089 
  def __eq__(self, other):
23090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23091 
 
23092 
  def __ne__(self, other):
23093 
    return not (self == other)
23094 
 
9242 kshitij.so 23095 
class getSnapdealItem_result:
8739 vikram.rag 23096 
  """
23097 
  Attributes:
23098 
   - success
23099 
  """
23100 
 
23101 
  thrift_spec = (
9242 kshitij.so 23102 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23103 
  )
23104 
 
23105 
  def __init__(self, success=None,):
23106 
    self.success = success
23107 
 
23108 
  def read(self, iprot):
23109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23111 
      return
23112 
    iprot.readStructBegin()
23113 
    while True:
23114 
      (fname, ftype, fid) = iprot.readFieldBegin()
23115 
      if ftype == TType.STOP:
23116 
        break
23117 
      if fid == 0:
9242 kshitij.so 23118 
        if ftype == TType.STRUCT:
23119 
          self.success = SnapdealItem()
23120 
          self.success.read(iprot)
8739 vikram.rag 23121 
        else:
23122 
          iprot.skip(ftype)
23123 
      else:
23124 
        iprot.skip(ftype)
23125 
      iprot.readFieldEnd()
23126 
    iprot.readStructEnd()
23127 
 
23128 
  def write(self, oprot):
23129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23131 
      return
9242 kshitij.so 23132 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23133 
    if self.success is not None:
9242 kshitij.so 23134 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23135 
      self.success.write(oprot)
8739 vikram.rag 23136 
      oprot.writeFieldEnd()
23137 
    oprot.writeFieldStop()
23138 
    oprot.writeStructEnd()
23139 
 
23140 
  def validate(self):
23141 
    return
23142 
 
23143 
 
23144 
  def __repr__(self):
23145 
    L = ['%s=%r' % (key, value)
23146 
      for key, value in self.__dict__.iteritems()]
23147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23148 
 
23149 
  def __eq__(self, other):
23150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23151 
 
23152 
  def __ne__(self, other):
23153 
    return not (self == other)
23154 
 
9242 kshitij.so 23155 
class getSnapdealItemDetails_args:
8739 vikram.rag 23156 
  """
23157 
  Attributes:
23158 
   - item_id
23159 
  """
23160 
 
23161 
  thrift_spec = (
23162 
    None, # 0
23163 
    (1, TType.I64, 'item_id', None, None, ), # 1
23164 
  )
23165 
 
23166 
  def __init__(self, item_id=None,):
23167 
    self.item_id = item_id
23168 
 
23169 
  def read(self, iprot):
23170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23172 
      return
23173 
    iprot.readStructBegin()
23174 
    while True:
23175 
      (fname, ftype, fid) = iprot.readFieldBegin()
23176 
      if ftype == TType.STOP:
23177 
        break
23178 
      if fid == 1:
23179 
        if ftype == TType.I64:
23180 
          self.item_id = iprot.readI64();
23181 
        else:
23182 
          iprot.skip(ftype)
23183 
      else:
23184 
        iprot.skip(ftype)
23185 
      iprot.readFieldEnd()
23186 
    iprot.readStructEnd()
23187 
 
23188 
  def write(self, oprot):
23189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23191 
      return
9242 kshitij.so 23192 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23193 
    if self.item_id is not None:
23194 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23195 
      oprot.writeI64(self.item_id)
23196 
      oprot.writeFieldEnd()
23197 
    oprot.writeFieldStop()
23198 
    oprot.writeStructEnd()
23199 
 
23200 
  def validate(self):
23201 
    return
23202 
 
23203 
 
23204 
  def __repr__(self):
23205 
    L = ['%s=%r' % (key, value)
23206 
      for key, value in self.__dict__.iteritems()]
23207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23208 
 
23209 
  def __eq__(self, other):
23210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23211 
 
23212 
  def __ne__(self, other):
23213 
    return not (self == other)
23214 
 
9242 kshitij.so 23215 
class getSnapdealItemDetails_result:
8739 vikram.rag 23216 
  """
23217 
  Attributes:
23218 
   - success
23219 
  """
23220 
 
23221 
  thrift_spec = (
9242 kshitij.so 23222 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23223 
  )
23224 
 
23225 
  def __init__(self, success=None,):
23226 
    self.success = success
23227 
 
23228 
  def read(self, iprot):
23229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23231 
      return
23232 
    iprot.readStructBegin()
23233 
    while True:
23234 
      (fname, ftype, fid) = iprot.readFieldBegin()
23235 
      if ftype == TType.STOP:
23236 
        break
23237 
      if fid == 0:
23238 
        if ftype == TType.STRUCT:
9242 kshitij.so 23239 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23240 
          self.success.read(iprot)
23241 
        else:
23242 
          iprot.skip(ftype)
23243 
      else:
23244 
        iprot.skip(ftype)
23245 
      iprot.readFieldEnd()
23246 
    iprot.readStructEnd()
23247 
 
23248 
  def write(self, oprot):
23249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23251 
      return
9242 kshitij.so 23252 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23253 
    if self.success is not None:
23254 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23255 
      self.success.write(oprot)
23256 
      oprot.writeFieldEnd()
23257 
    oprot.writeFieldStop()
23258 
    oprot.writeStructEnd()
23259 
 
23260 
  def validate(self):
23261 
    return
23262 
 
23263 
 
23264 
  def __repr__(self):
23265 
    L = ['%s=%r' % (key, value)
23266 
      for key, value in self.__dict__.iteritems()]
23267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23268 
 
23269 
  def __eq__(self, other):
23270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23271 
 
23272 
  def __ne__(self, other):
23273 
    return not (self == other)
23274 
 
23275 
class getAllSnapdealItems_args:
23276 
 
23277 
  thrift_spec = (
23278 
  )
23279 
 
23280 
  def read(self, iprot):
23281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23283 
      return
23284 
    iprot.readStructBegin()
23285 
    while True:
23286 
      (fname, ftype, fid) = iprot.readFieldBegin()
23287 
      if ftype == TType.STOP:
23288 
        break
23289 
      else:
23290 
        iprot.skip(ftype)
23291 
      iprot.readFieldEnd()
23292 
    iprot.readStructEnd()
23293 
 
23294 
  def write(self, oprot):
23295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23297 
      return
23298 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23299 
    oprot.writeFieldStop()
23300 
    oprot.writeStructEnd()
23301 
 
23302 
  def validate(self):
23303 
    return
23304 
 
23305 
 
23306 
  def __repr__(self):
23307 
    L = ['%s=%r' % (key, value)
23308 
      for key, value in self.__dict__.iteritems()]
23309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23310 
 
23311 
  def __eq__(self, other):
23312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23313 
 
23314 
  def __ne__(self, other):
23315 
    return not (self == other)
23316 
 
23317 
class getAllSnapdealItems_result:
23318 
  """
23319 
  Attributes:
23320 
   - success
23321 
  """
23322 
 
23323 
  thrift_spec = (
9242 kshitij.so 23324 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23325 
  )
23326 
 
23327 
  def __init__(self, success=None,):
23328 
    self.success = success
23329 
 
23330 
  def read(self, iprot):
23331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23333 
      return
23334 
    iprot.readStructBegin()
23335 
    while True:
23336 
      (fname, ftype, fid) = iprot.readFieldBegin()
23337 
      if ftype == TType.STOP:
23338 
        break
23339 
      if fid == 0:
23340 
        if ftype == TType.LIST:
23341 
          self.success = []
9242 kshitij.so 23342 
          (_etype516, _size513) = iprot.readListBegin()
23343 
          for _i517 in xrange(_size513):
23344 
            _elem518 = SnapdealItemDetails()
23345 
            _elem518.read(iprot)
23346 
            self.success.append(_elem518)
23347 
          iprot.readListEnd()
23348 
        else:
23349 
          iprot.skip(ftype)
23350 
      else:
23351 
        iprot.skip(ftype)
23352 
      iprot.readFieldEnd()
23353 
    iprot.readStructEnd()
23354 
 
23355 
  def write(self, oprot):
23356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23358 
      return
23359 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23360 
    if self.success is not None:
23361 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23362 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23363 
      for iter519 in self.success:
23364 
        iter519.write(oprot)
23365 
      oprot.writeListEnd()
23366 
      oprot.writeFieldEnd()
23367 
    oprot.writeFieldStop()
23368 
    oprot.writeStructEnd()
23369 
 
23370 
  def validate(self):
23371 
    return
23372 
 
23373 
 
23374 
  def __repr__(self):
23375 
    L = ['%s=%r' % (key, value)
23376 
      for key, value in self.__dict__.iteritems()]
23377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23378 
 
23379 
  def __eq__(self, other):
23380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23381 
 
23382 
  def __ne__(self, other):
23383 
    return not (self == other)
23384 
 
23385 
class getSnapdealItems_args:
23386 
  """
23387 
  Attributes:
23388 
   - offset
23389 
   - limit
23390 
  """
23391 
 
23392 
  thrift_spec = (
23393 
    None, # 0
23394 
    (1, TType.I64, 'offset', None, None, ), # 1
23395 
    (2, TType.I64, 'limit', None, None, ), # 2
23396 
  )
23397 
 
23398 
  def __init__(self, offset=None, limit=None,):
23399 
    self.offset = offset
23400 
    self.limit = limit
23401 
 
23402 
  def read(self, iprot):
23403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23405 
      return
23406 
    iprot.readStructBegin()
23407 
    while True:
23408 
      (fname, ftype, fid) = iprot.readFieldBegin()
23409 
      if ftype == TType.STOP:
23410 
        break
23411 
      if fid == 1:
23412 
        if ftype == TType.I64:
23413 
          self.offset = iprot.readI64();
23414 
        else:
23415 
          iprot.skip(ftype)
23416 
      elif fid == 2:
23417 
        if ftype == TType.I64:
23418 
          self.limit = iprot.readI64();
23419 
        else:
23420 
          iprot.skip(ftype)
23421 
      else:
23422 
        iprot.skip(ftype)
23423 
      iprot.readFieldEnd()
23424 
    iprot.readStructEnd()
23425 
 
23426 
  def write(self, oprot):
23427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23429 
      return
23430 
    oprot.writeStructBegin('getSnapdealItems_args')
23431 
    if self.offset is not None:
23432 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23433 
      oprot.writeI64(self.offset)
23434 
      oprot.writeFieldEnd()
23435 
    if self.limit is not None:
23436 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23437 
      oprot.writeI64(self.limit)
23438 
      oprot.writeFieldEnd()
23439 
    oprot.writeFieldStop()
23440 
    oprot.writeStructEnd()
23441 
 
23442 
  def validate(self):
23443 
    return
23444 
 
23445 
 
23446 
  def __repr__(self):
23447 
    L = ['%s=%r' % (key, value)
23448 
      for key, value in self.__dict__.iteritems()]
23449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23450 
 
23451 
  def __eq__(self, other):
23452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23453 
 
23454 
  def __ne__(self, other):
23455 
    return not (self == other)
23456 
 
23457 
class getSnapdealItems_result:
23458 
  """
23459 
  Attributes:
23460 
   - success
23461 
  """
23462 
 
23463 
  thrift_spec = (
23464 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23465 
  )
23466 
 
23467 
  def __init__(self, success=None,):
23468 
    self.success = success
23469 
 
23470 
  def read(self, iprot):
23471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23473 
      return
23474 
    iprot.readStructBegin()
23475 
    while True:
23476 
      (fname, ftype, fid) = iprot.readFieldBegin()
23477 
      if ftype == TType.STOP:
23478 
        break
23479 
      if fid == 0:
23480 
        if ftype == TType.LIST:
23481 
          self.success = []
9155 kshitij.so 23482 
          (_etype523, _size520) = iprot.readListBegin()
23483 
          for _i524 in xrange(_size520):
9242 kshitij.so 23484 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23485 
            _elem525.read(iprot)
23486 
            self.success.append(_elem525)
8739 vikram.rag 23487 
          iprot.readListEnd()
23488 
        else:
23489 
          iprot.skip(ftype)
23490 
      else:
23491 
        iprot.skip(ftype)
23492 
      iprot.readFieldEnd()
23493 
    iprot.readStructEnd()
23494 
 
23495 
  def write(self, oprot):
23496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23498 
      return
9242 kshitij.so 23499 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23500 
    if self.success is not None:
23501 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23502 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23503 
      for iter526 in self.success:
23504 
        iter526.write(oprot)
8739 vikram.rag 23505 
      oprot.writeListEnd()
23506 
      oprot.writeFieldEnd()
23507 
    oprot.writeFieldStop()
23508 
    oprot.writeStructEnd()
23509 
 
23510 
  def validate(self):
23511 
    return
23512 
 
23513 
 
23514 
  def __repr__(self):
23515 
    L = ['%s=%r' % (key, value)
23516 
      for key, value in self.__dict__.iteritems()]
23517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23518 
 
23519 
  def __eq__(self, other):
23520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23521 
 
23522 
  def __ne__(self, other):
23523 
    return not (self == other)
9242 kshitij.so 23524 
 
23525 
class searchSnapdealItems_args:
23526 
  """
23527 
  Attributes:
23528 
   - searchTerm
23529 
   - offset
23530 
   - limit
23531 
  """
23532 
 
23533 
  thrift_spec = (
23534 
    None, # 0
23535 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23536 
    (2, TType.I64, 'offset', None, None, ), # 2
23537 
    (3, TType.I64, 'limit', None, None, ), # 3
23538 
  )
23539 
 
23540 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23541 
    self.searchTerm = searchTerm
23542 
    self.offset = offset
23543 
    self.limit = limit
23544 
 
23545 
  def read(self, iprot):
23546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23548 
      return
23549 
    iprot.readStructBegin()
23550 
    while True:
23551 
      (fname, ftype, fid) = iprot.readFieldBegin()
23552 
      if ftype == TType.STOP:
23553 
        break
23554 
      if fid == 1:
23555 
        if ftype == TType.LIST:
23556 
          self.searchTerm = []
23557 
          (_etype530, _size527) = iprot.readListBegin()
23558 
          for _i531 in xrange(_size527):
23559 
            _elem532 = iprot.readString();
23560 
            self.searchTerm.append(_elem532)
23561 
          iprot.readListEnd()
23562 
        else:
23563 
          iprot.skip(ftype)
23564 
      elif fid == 2:
23565 
        if ftype == TType.I64:
23566 
          self.offset = iprot.readI64();
23567 
        else:
23568 
          iprot.skip(ftype)
23569 
      elif fid == 3:
23570 
        if ftype == TType.I64:
23571 
          self.limit = iprot.readI64();
23572 
        else:
23573 
          iprot.skip(ftype)
23574 
      else:
23575 
        iprot.skip(ftype)
23576 
      iprot.readFieldEnd()
23577 
    iprot.readStructEnd()
23578 
 
23579 
  def write(self, oprot):
23580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23582 
      return
23583 
    oprot.writeStructBegin('searchSnapdealItems_args')
23584 
    if self.searchTerm is not None:
23585 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23586 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23587 
      for iter533 in self.searchTerm:
23588 
        oprot.writeString(iter533)
23589 
      oprot.writeListEnd()
23590 
      oprot.writeFieldEnd()
23591 
    if self.offset is not None:
23592 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23593 
      oprot.writeI64(self.offset)
23594 
      oprot.writeFieldEnd()
23595 
    if self.limit is not None:
23596 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23597 
      oprot.writeI64(self.limit)
23598 
      oprot.writeFieldEnd()
23599 
    oprot.writeFieldStop()
23600 
    oprot.writeStructEnd()
23601 
 
23602 
  def validate(self):
23603 
    return
23604 
 
23605 
 
23606 
  def __repr__(self):
23607 
    L = ['%s=%r' % (key, value)
23608 
      for key, value in self.__dict__.iteritems()]
23609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23610 
 
23611 
  def __eq__(self, other):
23612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23613 
 
23614 
  def __ne__(self, other):
23615 
    return not (self == other)
23616 
 
23617 
class searchSnapdealItems_result:
23618 
  """
23619 
  Attributes:
23620 
   - success
23621 
  """
23622 
 
23623 
  thrift_spec = (
23624 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23625 
  )
23626 
 
23627 
  def __init__(self, success=None,):
23628 
    self.success = success
23629 
 
23630 
  def read(self, iprot):
23631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23633 
      return
23634 
    iprot.readStructBegin()
23635 
    while True:
23636 
      (fname, ftype, fid) = iprot.readFieldBegin()
23637 
      if ftype == TType.STOP:
23638 
        break
23639 
      if fid == 0:
23640 
        if ftype == TType.LIST:
23641 
          self.success = []
23642 
          (_etype537, _size534) = iprot.readListBegin()
23643 
          for _i538 in xrange(_size534):
23644 
            _elem539 = SnapdealItemDetails()
23645 
            _elem539.read(iprot)
23646 
            self.success.append(_elem539)
23647 
          iprot.readListEnd()
23648 
        else:
23649 
          iprot.skip(ftype)
23650 
      else:
23651 
        iprot.skip(ftype)
23652 
      iprot.readFieldEnd()
23653 
    iprot.readStructEnd()
23654 
 
23655 
  def write(self, oprot):
23656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23658 
      return
23659 
    oprot.writeStructBegin('searchSnapdealItems_result')
23660 
    if self.success is not None:
23661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23663 
      for iter540 in self.success:
23664 
        iter540.write(oprot)
23665 
      oprot.writeListEnd()
23666 
      oprot.writeFieldEnd()
23667 
    oprot.writeFieldStop()
23668 
    oprot.writeStructEnd()
23669 
 
23670 
  def validate(self):
23671 
    return
23672 
 
23673 
 
23674 
  def __repr__(self):
23675 
    L = ['%s=%r' % (key, value)
23676 
      for key, value in self.__dict__.iteritems()]
23677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23678 
 
23679 
  def __eq__(self, other):
23680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23681 
 
23682 
  def __ne__(self, other):
23683 
    return not (self == other)
23684 
 
23685 
class getCountForSnapdealItems_args:
23686 
 
23687 
  thrift_spec = (
23688 
  )
23689 
 
23690 
  def read(self, iprot):
23691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23693 
      return
23694 
    iprot.readStructBegin()
23695 
    while True:
23696 
      (fname, ftype, fid) = iprot.readFieldBegin()
23697 
      if ftype == TType.STOP:
23698 
        break
23699 
      else:
23700 
        iprot.skip(ftype)
23701 
      iprot.readFieldEnd()
23702 
    iprot.readStructEnd()
23703 
 
23704 
  def write(self, oprot):
23705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23707 
      return
23708 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23709 
    oprot.writeFieldStop()
23710 
    oprot.writeStructEnd()
23711 
 
23712 
  def validate(self):
23713 
    return
23714 
 
23715 
 
23716 
  def __repr__(self):
23717 
    L = ['%s=%r' % (key, value)
23718 
      for key, value in self.__dict__.iteritems()]
23719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23720 
 
23721 
  def __eq__(self, other):
23722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23723 
 
23724 
  def __ne__(self, other):
23725 
    return not (self == other)
23726 
 
23727 
class getCountForSnapdealItems_result:
23728 
  """
23729 
  Attributes:
23730 
   - success
23731 
  """
23732 
 
23733 
  thrift_spec = (
23734 
    (0, TType.I64, 'success', None, None, ), # 0
23735 
  )
23736 
 
23737 
  def __init__(self, success=None,):
23738 
    self.success = success
23739 
 
23740 
  def read(self, iprot):
23741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23743 
      return
23744 
    iprot.readStructBegin()
23745 
    while True:
23746 
      (fname, ftype, fid) = iprot.readFieldBegin()
23747 
      if ftype == TType.STOP:
23748 
        break
23749 
      if fid == 0:
23750 
        if ftype == TType.I64:
23751 
          self.success = iprot.readI64();
23752 
        else:
23753 
          iprot.skip(ftype)
23754 
      else:
23755 
        iprot.skip(ftype)
23756 
      iprot.readFieldEnd()
23757 
    iprot.readStructEnd()
23758 
 
23759 
  def write(self, oprot):
23760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23762 
      return
23763 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23764 
    if self.success is not None:
23765 
      oprot.writeFieldBegin('success', TType.I64, 0)
23766 
      oprot.writeI64(self.success)
23767 
      oprot.writeFieldEnd()
23768 
    oprot.writeFieldStop()
23769 
    oprot.writeStructEnd()
23770 
 
23771 
  def validate(self):
23772 
    return
23773 
 
23774 
 
23775 
  def __repr__(self):
23776 
    L = ['%s=%r' % (key, value)
23777 
      for key, value in self.__dict__.iteritems()]
23778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23779 
 
23780 
  def __eq__(self, other):
23781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23782 
 
23783 
  def __ne__(self, other):
23784 
    return not (self == other)
23785 
 
23786 
class getSnapdealSearchResultCount_args:
23787 
  """
23788 
  Attributes:
23789 
   - searchTerm
23790 
  """
23791 
 
23792 
  thrift_spec = (
23793 
    None, # 0
23794 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23795 
  )
23796 
 
23797 
  def __init__(self, searchTerm=None,):
23798 
    self.searchTerm = searchTerm
23799 
 
23800 
  def read(self, iprot):
23801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23803 
      return
23804 
    iprot.readStructBegin()
23805 
    while True:
23806 
      (fname, ftype, fid) = iprot.readFieldBegin()
23807 
      if ftype == TType.STOP:
23808 
        break
23809 
      if fid == 1:
23810 
        if ftype == TType.LIST:
23811 
          self.searchTerm = []
23812 
          (_etype544, _size541) = iprot.readListBegin()
23813 
          for _i545 in xrange(_size541):
23814 
            _elem546 = iprot.readString();
23815 
            self.searchTerm.append(_elem546)
23816 
          iprot.readListEnd()
23817 
        else:
23818 
          iprot.skip(ftype)
23819 
      else:
23820 
        iprot.skip(ftype)
23821 
      iprot.readFieldEnd()
23822 
    iprot.readStructEnd()
23823 
 
23824 
  def write(self, oprot):
23825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23827 
      return
23828 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23829 
    if self.searchTerm is not None:
23830 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23831 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23832 
      for iter547 in self.searchTerm:
23833 
        oprot.writeString(iter547)
23834 
      oprot.writeListEnd()
23835 
      oprot.writeFieldEnd()
23836 
    oprot.writeFieldStop()
23837 
    oprot.writeStructEnd()
23838 
 
23839 
  def validate(self):
23840 
    return
23841 
 
23842 
 
23843 
  def __repr__(self):
23844 
    L = ['%s=%r' % (key, value)
23845 
      for key, value in self.__dict__.iteritems()]
23846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23847 
 
23848 
  def __eq__(self, other):
23849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23850 
 
23851 
  def __ne__(self, other):
23852 
    return not (self == other)
23853 
 
23854 
class getSnapdealSearchResultCount_result:
23855 
  """
23856 
  Attributes:
23857 
   - success
23858 
  """
23859 
 
23860 
  thrift_spec = (
23861 
    (0, TType.I64, 'success', None, None, ), # 0
23862 
  )
23863 
 
23864 
  def __init__(self, success=None,):
23865 
    self.success = success
23866 
 
23867 
  def read(self, iprot):
23868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23870 
      return
23871 
    iprot.readStructBegin()
23872 
    while True:
23873 
      (fname, ftype, fid) = iprot.readFieldBegin()
23874 
      if ftype == TType.STOP:
23875 
        break
23876 
      if fid == 0:
23877 
        if ftype == TType.I64:
23878 
          self.success = iprot.readI64();
23879 
        else:
23880 
          iprot.skip(ftype)
23881 
      else:
23882 
        iprot.skip(ftype)
23883 
      iprot.readFieldEnd()
23884 
    iprot.readStructEnd()
23885 
 
23886 
  def write(self, oprot):
23887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23889 
      return
23890 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23891 
    if self.success is not None:
23892 
      oprot.writeFieldBegin('success', TType.I64, 0)
23893 
      oprot.writeI64(self.success)
23894 
      oprot.writeFieldEnd()
23895 
    oprot.writeFieldStop()
23896 
    oprot.writeStructEnd()
23897 
 
23898 
  def validate(self):
23899 
    return
23900 
 
23901 
 
23902 
  def __repr__(self):
23903 
    L = ['%s=%r' % (key, value)
23904 
      for key, value in self.__dict__.iteritems()]
23905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23906 
 
23907 
  def __eq__(self, other):
23908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23909 
 
23910 
  def __ne__(self, other):
23911 
    return not (self == other)
9299 kshitij.so 23912 
 
23913 
class getPrefferedInsurerForItem_args:
23914 
  """
23915 
  Attributes:
23916 
   - itemId
23917 
   - insurerType
23918 
  """
23919 
 
23920 
  thrift_spec = (
23921 
    None, # 0
23922 
    (1, TType.I64, 'itemId', None, None, ), # 1
23923 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23924 
  )
23925 
 
23926 
  def __init__(self, itemId=None, insurerType=None,):
23927 
    self.itemId = itemId
23928 
    self.insurerType = insurerType
23929 
 
23930 
  def read(self, iprot):
23931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23933 
      return
23934 
    iprot.readStructBegin()
23935 
    while True:
23936 
      (fname, ftype, fid) = iprot.readFieldBegin()
23937 
      if ftype == TType.STOP:
23938 
        break
23939 
      if fid == 1:
23940 
        if ftype == TType.I64:
23941 
          self.itemId = iprot.readI64();
23942 
        else:
23943 
          iprot.skip(ftype)
23944 
      elif fid == 2:
23945 
        if ftype == TType.I32:
23946 
          self.insurerType = iprot.readI32();
23947 
        else:
23948 
          iprot.skip(ftype)
23949 
      else:
23950 
        iprot.skip(ftype)
23951 
      iprot.readFieldEnd()
23952 
    iprot.readStructEnd()
23953 
 
23954 
  def write(self, oprot):
23955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23957 
      return
23958 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23959 
    if self.itemId is not None:
23960 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23961 
      oprot.writeI64(self.itemId)
23962 
      oprot.writeFieldEnd()
23963 
    if self.insurerType is not None:
23964 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23965 
      oprot.writeI32(self.insurerType)
23966 
      oprot.writeFieldEnd()
23967 
    oprot.writeFieldStop()
23968 
    oprot.writeStructEnd()
23969 
 
23970 
  def validate(self):
23971 
    return
23972 
 
23973 
 
23974 
  def __repr__(self):
23975 
    L = ['%s=%r' % (key, value)
23976 
      for key, value in self.__dict__.iteritems()]
23977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23978 
 
23979 
  def __eq__(self, other):
23980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23981 
 
23982 
  def __ne__(self, other):
23983 
    return not (self == other)
23984 
 
23985 
class getPrefferedInsurerForItem_result:
23986 
  """
23987 
  Attributes:
23988 
   - success
23989 
  """
23990 
 
23991 
  thrift_spec = (
23992 
    (0, TType.I64, 'success', None, None, ), # 0
23993 
  )
23994 
 
23995 
  def __init__(self, success=None,):
23996 
    self.success = success
23997 
 
23998 
  def read(self, iprot):
23999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24001 
      return
24002 
    iprot.readStructBegin()
24003 
    while True:
24004 
      (fname, ftype, fid) = iprot.readFieldBegin()
24005 
      if ftype == TType.STOP:
24006 
        break
24007 
      if fid == 0:
24008 
        if ftype == TType.I64:
24009 
          self.success = iprot.readI64();
24010 
        else:
24011 
          iprot.skip(ftype)
24012 
      else:
24013 
        iprot.skip(ftype)
24014 
      iprot.readFieldEnd()
24015 
    iprot.readStructEnd()
24016 
 
24017 
  def write(self, oprot):
24018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24020 
      return
24021 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24022 
    if self.success is not None:
24023 
      oprot.writeFieldBegin('success', TType.I64, 0)
24024 
      oprot.writeI64(self.success)
24025 
      oprot.writeFieldEnd()
24026 
    oprot.writeFieldStop()
24027 
    oprot.writeStructEnd()
24028 
 
24029 
  def validate(self):
24030 
    return
24031 
 
24032 
 
24033 
  def __repr__(self):
24034 
    L = ['%s=%r' % (key, value)
24035 
      for key, value in self.__dict__.iteritems()]
24036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24037 
 
24038 
  def __eq__(self, other):
24039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24040 
 
24041 
  def __ne__(self, other):
24042 
    return not (self == other)
9456 vikram.rag 24043 
 
24044 
class getSnapdealItembySkuAtSnapdeal_args:
24045 
  """
24046 
  Attributes:
24047 
   - skuAtSnapdeal
24048 
  """
24049 
 
24050 
  thrift_spec = None
24051 
  def __init__(self, skuAtSnapdeal=None,):
24052 
    self.skuAtSnapdeal = skuAtSnapdeal
24053 
 
24054 
  def read(self, iprot):
24055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24057 
      return
24058 
    iprot.readStructBegin()
24059 
    while True:
24060 
      (fname, ftype, fid) = iprot.readFieldBegin()
24061 
      if ftype == TType.STOP:
24062 
        break
24063 
      if fid == -1:
24064 
        if ftype == TType.STRING:
24065 
          self.skuAtSnapdeal = iprot.readString();
24066 
        else:
24067 
          iprot.skip(ftype)
24068 
      else:
24069 
        iprot.skip(ftype)
24070 
      iprot.readFieldEnd()
24071 
    iprot.readStructEnd()
24072 
 
24073 
  def write(self, oprot):
24074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24076 
      return
24077 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24078 
    if self.skuAtSnapdeal is not None:
24079 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24080 
      oprot.writeString(self.skuAtSnapdeal)
24081 
      oprot.writeFieldEnd()
24082 
    oprot.writeFieldStop()
24083 
    oprot.writeStructEnd()
24084 
 
24085 
  def validate(self):
24086 
    return
24087 
 
24088 
 
24089 
  def __repr__(self):
24090 
    L = ['%s=%r' % (key, value)
24091 
      for key, value in self.__dict__.iteritems()]
24092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24093 
 
24094 
  def __eq__(self, other):
24095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24096 
 
24097 
  def __ne__(self, other):
24098 
    return not (self == other)
24099 
 
24100 
class getSnapdealItembySkuAtSnapdeal_result:
24101 
  """
24102 
  Attributes:
24103 
   - success
24104 
  """
24105 
 
24106 
  thrift_spec = (
24107 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24108 
  )
24109 
 
24110 
  def __init__(self, success=None,):
24111 
    self.success = success
24112 
 
24113 
  def read(self, iprot):
24114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24116 
      return
24117 
    iprot.readStructBegin()
24118 
    while True:
24119 
      (fname, ftype, fid) = iprot.readFieldBegin()
24120 
      if ftype == TType.STOP:
24121 
        break
24122 
      if fid == 0:
24123 
        if ftype == TType.STRUCT:
24124 
          self.success = SnapdealItem()
24125 
          self.success.read(iprot)
24126 
        else:
24127 
          iprot.skip(ftype)
24128 
      else:
24129 
        iprot.skip(ftype)
24130 
      iprot.readFieldEnd()
24131 
    iprot.readStructEnd()
24132 
 
24133 
  def write(self, oprot):
24134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24136 
      return
24137 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24138 
    if self.success is not None:
24139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24140 
      self.success.write(oprot)
24141 
      oprot.writeFieldEnd()
24142 
    oprot.writeFieldStop()
24143 
    oprot.writeStructEnd()
24144 
 
24145 
  def validate(self):
24146 
    return
24147 
 
24148 
 
24149 
  def __repr__(self):
24150 
    L = ['%s=%r' % (key, value)
24151 
      for key, value in self.__dict__.iteritems()]
24152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24153 
 
24154 
  def __eq__(self, other):
24155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24156 
 
24157 
  def __ne__(self, other):
24158 
    return not (self == other)
9621 manish.sha 24159 
 
24160 
class getProductFeedSubmit_args:
24161 
  """
24162 
  Attributes:
24163 
   - catalogItemId
24164 
  """
24165 
 
24166 
  thrift_spec = (
24167 
    None, # 0
24168 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24169 
  )
24170 
 
24171 
  def __init__(self, catalogItemId=None,):
24172 
    self.catalogItemId = catalogItemId
24173 
 
24174 
  def read(self, iprot):
24175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24177 
      return
24178 
    iprot.readStructBegin()
24179 
    while True:
24180 
      (fname, ftype, fid) = iprot.readFieldBegin()
24181 
      if ftype == TType.STOP:
24182 
        break
24183 
      if fid == 1:
24184 
        if ftype == TType.I64:
24185 
          self.catalogItemId = iprot.readI64();
24186 
        else:
24187 
          iprot.skip(ftype)
24188 
      else:
24189 
        iprot.skip(ftype)
24190 
      iprot.readFieldEnd()
24191 
    iprot.readStructEnd()
24192 
 
24193 
  def write(self, oprot):
24194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24196 
      return
24197 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24198 
    if self.catalogItemId is not None:
24199 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24200 
      oprot.writeI64(self.catalogItemId)
24201 
      oprot.writeFieldEnd()
24202 
    oprot.writeFieldStop()
24203 
    oprot.writeStructEnd()
24204 
 
24205 
  def validate(self):
24206 
    return
24207 
 
24208 
 
24209 
  def __repr__(self):
24210 
    L = ['%s=%r' % (key, value)
24211 
      for key, value in self.__dict__.iteritems()]
24212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24213 
 
24214 
  def __eq__(self, other):
24215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24216 
 
24217 
  def __ne__(self, other):
24218 
    return not (self == other)
24219 
 
24220 
class getProductFeedSubmit_result:
24221 
  """
24222 
  Attributes:
24223 
   - success
24224 
   - cex
24225 
  """
24226 
 
24227 
  thrift_spec = (
24228 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24229 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24230 
  )
24231 
 
24232 
  def __init__(self, success=None, cex=None,):
24233 
    self.success = success
24234 
    self.cex = cex
24235 
 
24236 
  def read(self, iprot):
24237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24239 
      return
24240 
    iprot.readStructBegin()
24241 
    while True:
24242 
      (fname, ftype, fid) = iprot.readFieldBegin()
24243 
      if ftype == TType.STOP:
24244 
        break
24245 
      if fid == 0:
24246 
        if ftype == TType.STRUCT:
24247 
          self.success = ProductFeedSubmit()
24248 
          self.success.read(iprot)
24249 
        else:
24250 
          iprot.skip(ftype)
24251 
      elif fid == 1:
24252 
        if ftype == TType.STRUCT:
24253 
          self.cex = CatalogServiceException()
24254 
          self.cex.read(iprot)
24255 
        else:
24256 
          iprot.skip(ftype)
24257 
      else:
24258 
        iprot.skip(ftype)
24259 
      iprot.readFieldEnd()
24260 
    iprot.readStructEnd()
24261 
 
24262 
  def write(self, oprot):
24263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24265 
      return
24266 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24267 
    if self.success is not None:
24268 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24269 
      self.success.write(oprot)
24270 
      oprot.writeFieldEnd()
24271 
    if self.cex is not None:
24272 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24273 
      self.cex.write(oprot)
24274 
      oprot.writeFieldEnd()
24275 
    oprot.writeFieldStop()
24276 
    oprot.writeStructEnd()
24277 
 
24278 
  def validate(self):
24279 
    return
24280 
 
24281 
 
24282 
  def __repr__(self):
24283 
    L = ['%s=%r' % (key, value)
24284 
      for key, value in self.__dict__.iteritems()]
24285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24286 
 
24287 
  def __eq__(self, other):
24288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24289 
 
24290 
  def __ne__(self, other):
24291 
    return not (self == other)
24292 
 
24293 
class addProductFeedSubmit_args:
24294 
  """
24295 
  Attributes:
24296 
   - productFeedSubmit
24297 
  """
24298 
 
24299 
  thrift_spec = (
24300 
    None, # 0
24301 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24302 
  )
24303 
 
24304 
  def __init__(self, productFeedSubmit=None,):
24305 
    self.productFeedSubmit = productFeedSubmit
24306 
 
24307 
  def read(self, iprot):
24308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24310 
      return
24311 
    iprot.readStructBegin()
24312 
    while True:
24313 
      (fname, ftype, fid) = iprot.readFieldBegin()
24314 
      if ftype == TType.STOP:
24315 
        break
24316 
      if fid == 1:
24317 
        if ftype == TType.STRUCT:
24318 
          self.productFeedSubmit = ProductFeedSubmit()
24319 
          self.productFeedSubmit.read(iprot)
24320 
        else:
24321 
          iprot.skip(ftype)
24322 
      else:
24323 
        iprot.skip(ftype)
24324 
      iprot.readFieldEnd()
24325 
    iprot.readStructEnd()
24326 
 
24327 
  def write(self, oprot):
24328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24330 
      return
24331 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24332 
    if self.productFeedSubmit is not None:
24333 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24334 
      self.productFeedSubmit.write(oprot)
24335 
      oprot.writeFieldEnd()
24336 
    oprot.writeFieldStop()
24337 
    oprot.writeStructEnd()
24338 
 
24339 
  def validate(self):
24340 
    return
24341 
 
24342 
 
24343 
  def __repr__(self):
24344 
    L = ['%s=%r' % (key, value)
24345 
      for key, value in self.__dict__.iteritems()]
24346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24347 
 
24348 
  def __eq__(self, other):
24349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24350 
 
24351 
  def __ne__(self, other):
24352 
    return not (self == other)
24353 
 
24354 
class addProductFeedSubmit_result:
24355 
  """
24356 
  Attributes:
24357 
   - success
24358 
   - cex
24359 
  """
24360 
 
24361 
  thrift_spec = (
24362 
    (0, TType.BOOL, 'success', None, None, ), # 0
24363 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24364 
  )
24365 
 
24366 
  def __init__(self, success=None, cex=None,):
24367 
    self.success = success
24368 
    self.cex = cex
24369 
 
24370 
  def read(self, iprot):
24371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24373 
      return
24374 
    iprot.readStructBegin()
24375 
    while True:
24376 
      (fname, ftype, fid) = iprot.readFieldBegin()
24377 
      if ftype == TType.STOP:
24378 
        break
24379 
      if fid == 0:
24380 
        if ftype == TType.BOOL:
24381 
          self.success = iprot.readBool();
24382 
        else:
24383 
          iprot.skip(ftype)
24384 
      elif fid == 1:
24385 
        if ftype == TType.STRUCT:
24386 
          self.cex = CatalogServiceException()
24387 
          self.cex.read(iprot)
24388 
        else:
24389 
          iprot.skip(ftype)
24390 
      else:
24391 
        iprot.skip(ftype)
24392 
      iprot.readFieldEnd()
24393 
    iprot.readStructEnd()
24394 
 
24395 
  def write(self, oprot):
24396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24398 
      return
24399 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24400 
    if self.success is not None:
24401 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24402 
      oprot.writeBool(self.success)
24403 
      oprot.writeFieldEnd()
24404 
    if self.cex is not None:
24405 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24406 
      self.cex.write(oprot)
24407 
      oprot.writeFieldEnd()
24408 
    oprot.writeFieldStop()
24409 
    oprot.writeStructEnd()
24410 
 
24411 
  def validate(self):
24412 
    return
24413 
 
24414 
 
24415 
  def __repr__(self):
24416 
    L = ['%s=%r' % (key, value)
24417 
      for key, value in self.__dict__.iteritems()]
24418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24419 
 
24420 
  def __eq__(self, other):
24421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24422 
 
24423 
  def __ne__(self, other):
24424 
    return not (self == other)
24425 
 
24426 
class updateProductFeedSubmit_args:
24427 
  """
24428 
  Attributes:
24429 
   - productFeedSubmit
24430 
  """
24431 
 
24432 
  thrift_spec = (
24433 
    None, # 0
24434 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24435 
  )
24436 
 
24437 
  def __init__(self, productFeedSubmit=None,):
24438 
    self.productFeedSubmit = productFeedSubmit
24439 
 
24440 
  def read(self, iprot):
24441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24443 
      return
24444 
    iprot.readStructBegin()
24445 
    while True:
24446 
      (fname, ftype, fid) = iprot.readFieldBegin()
24447 
      if ftype == TType.STOP:
24448 
        break
24449 
      if fid == 1:
24450 
        if ftype == TType.STRUCT:
24451 
          self.productFeedSubmit = ProductFeedSubmit()
24452 
          self.productFeedSubmit.read(iprot)
24453 
        else:
24454 
          iprot.skip(ftype)
24455 
      else:
24456 
        iprot.skip(ftype)
24457 
      iprot.readFieldEnd()
24458 
    iprot.readStructEnd()
24459 
 
24460 
  def write(self, oprot):
24461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24463 
      return
24464 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24465 
    if self.productFeedSubmit is not None:
24466 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24467 
      self.productFeedSubmit.write(oprot)
24468 
      oprot.writeFieldEnd()
24469 
    oprot.writeFieldStop()
24470 
    oprot.writeStructEnd()
24471 
 
24472 
  def validate(self):
24473 
    return
24474 
 
24475 
 
24476 
  def __repr__(self):
24477 
    L = ['%s=%r' % (key, value)
24478 
      for key, value in self.__dict__.iteritems()]
24479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24480 
 
24481 
  def __eq__(self, other):
24482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24483 
 
24484 
  def __ne__(self, other):
24485 
    return not (self == other)
24486 
 
24487 
class updateProductFeedSubmit_result:
24488 
  """
24489 
  Attributes:
24490 
   - success
24491 
   - cex
24492 
  """
24493 
 
24494 
  thrift_spec = (
24495 
    (0, TType.BOOL, 'success', None, None, ), # 0
24496 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24497 
  )
24498 
 
24499 
  def __init__(self, success=None, cex=None,):
24500 
    self.success = success
24501 
    self.cex = cex
24502 
 
24503 
  def read(self, iprot):
24504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24506 
      return
24507 
    iprot.readStructBegin()
24508 
    while True:
24509 
      (fname, ftype, fid) = iprot.readFieldBegin()
24510 
      if ftype == TType.STOP:
24511 
        break
24512 
      if fid == 0:
24513 
        if ftype == TType.BOOL:
24514 
          self.success = iprot.readBool();
24515 
        else:
24516 
          iprot.skip(ftype)
24517 
      elif fid == 1:
24518 
        if ftype == TType.STRUCT:
24519 
          self.cex = CatalogServiceException()
24520 
          self.cex.read(iprot)
24521 
        else:
24522 
          iprot.skip(ftype)
24523 
      else:
24524 
        iprot.skip(ftype)
24525 
      iprot.readFieldEnd()
24526 
    iprot.readStructEnd()
24527 
 
24528 
  def write(self, oprot):
24529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24531 
      return
24532 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24533 
    if self.success is not None:
24534 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24535 
      oprot.writeBool(self.success)
24536 
      oprot.writeFieldEnd()
24537 
    if self.cex is not None:
24538 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24539 
      self.cex.write(oprot)
24540 
      oprot.writeFieldEnd()
24541 
    oprot.writeFieldStop()
24542 
    oprot.writeStructEnd()
24543 
 
24544 
  def validate(self):
24545 
    return
24546 
 
24547 
 
24548 
  def __repr__(self):
24549 
    L = ['%s=%r' % (key, value)
24550 
      for key, value in self.__dict__.iteritems()]
24551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24552 
 
24553 
  def __eq__(self, other):
24554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24555 
 
24556 
  def __ne__(self, other):
24557 
    return not (self == other)
24558 
 
24559 
class deleteProductFeedSubmit_args:
24560 
  """
24561 
  Attributes:
24562 
   - catalogItemId
24563 
  """
24564 
 
24565 
  thrift_spec = (
24566 
    None, # 0
24567 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24568 
  )
24569 
 
24570 
  def __init__(self, catalogItemId=None,):
24571 
    self.catalogItemId = catalogItemId
24572 
 
24573 
  def read(self, iprot):
24574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24576 
      return
24577 
    iprot.readStructBegin()
24578 
    while True:
24579 
      (fname, ftype, fid) = iprot.readFieldBegin()
24580 
      if ftype == TType.STOP:
24581 
        break
24582 
      if fid == 1:
24583 
        if ftype == TType.I64:
24584 
          self.catalogItemId = iprot.readI64();
24585 
        else:
24586 
          iprot.skip(ftype)
24587 
      else:
24588 
        iprot.skip(ftype)
24589 
      iprot.readFieldEnd()
24590 
    iprot.readStructEnd()
24591 
 
24592 
  def write(self, oprot):
24593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24595 
      return
24596 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24597 
    if self.catalogItemId is not None:
24598 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24599 
      oprot.writeI64(self.catalogItemId)
24600 
      oprot.writeFieldEnd()
24601 
    oprot.writeFieldStop()
24602 
    oprot.writeStructEnd()
24603 
 
24604 
  def validate(self):
24605 
    return
24606 
 
24607 
 
24608 
  def __repr__(self):
24609 
    L = ['%s=%r' % (key, value)
24610 
      for key, value in self.__dict__.iteritems()]
24611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24612 
 
24613 
  def __eq__(self, other):
24614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24615 
 
24616 
  def __ne__(self, other):
24617 
    return not (self == other)
24618 
 
24619 
class deleteProductFeedSubmit_result:
24620 
  """
24621 
  Attributes:
24622 
   - success
24623 
   - cex
24624 
  """
24625 
 
24626 
  thrift_spec = (
24627 
    (0, TType.BOOL, 'success', None, None, ), # 0
24628 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24629 
  )
24630 
 
24631 
  def __init__(self, success=None, cex=None,):
24632 
    self.success = success
24633 
    self.cex = cex
24634 
 
24635 
  def read(self, iprot):
24636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24638 
      return
24639 
    iprot.readStructBegin()
24640 
    while True:
24641 
      (fname, ftype, fid) = iprot.readFieldBegin()
24642 
      if ftype == TType.STOP:
24643 
        break
24644 
      if fid == 0:
24645 
        if ftype == TType.BOOL:
24646 
          self.success = iprot.readBool();
24647 
        else:
24648 
          iprot.skip(ftype)
24649 
      elif fid == 1:
24650 
        if ftype == TType.STRUCT:
24651 
          self.cex = CatalogServiceException()
24652 
          self.cex.read(iprot)
24653 
        else:
24654 
          iprot.skip(ftype)
24655 
      else:
24656 
        iprot.skip(ftype)
24657 
      iprot.readFieldEnd()
24658 
    iprot.readStructEnd()
24659 
 
24660 
  def write(self, oprot):
24661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24663 
      return
24664 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24665 
    if self.success is not None:
24666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24667 
      oprot.writeBool(self.success)
24668 
      oprot.writeFieldEnd()
24669 
    if self.cex is not None:
24670 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24671 
      self.cex.write(oprot)
24672 
      oprot.writeFieldEnd()
24673 
    oprot.writeFieldStop()
24674 
    oprot.writeStructEnd()
24675 
 
24676 
  def validate(self):
24677 
    return
24678 
 
24679 
 
24680 
  def __repr__(self):
24681 
    L = ['%s=%r' % (key, value)
24682 
      for key, value in self.__dict__.iteritems()]
24683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24684 
 
24685 
  def __eq__(self, other):
24686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24687 
 
24688 
  def __ne__(self, other):
24689 
    return not (self == other)
24690 
 
24691 
class getAllProductFeedSubmit_args:
24692 
 
24693 
  thrift_spec = (
24694 
  )
24695 
 
24696 
  def read(self, iprot):
24697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24699 
      return
24700 
    iprot.readStructBegin()
24701 
    while True:
24702 
      (fname, ftype, fid) = iprot.readFieldBegin()
24703 
      if ftype == TType.STOP:
24704 
        break
24705 
      else:
24706 
        iprot.skip(ftype)
24707 
      iprot.readFieldEnd()
24708 
    iprot.readStructEnd()
24709 
 
24710 
  def write(self, oprot):
24711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24713 
      return
24714 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24715 
    oprot.writeFieldStop()
24716 
    oprot.writeStructEnd()
24717 
 
24718 
  def validate(self):
24719 
    return
24720 
 
24721 
 
24722 
  def __repr__(self):
24723 
    L = ['%s=%r' % (key, value)
24724 
      for key, value in self.__dict__.iteritems()]
24725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24726 
 
24727 
  def __eq__(self, other):
24728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24729 
 
24730 
  def __ne__(self, other):
24731 
    return not (self == other)
24732 
 
24733 
class getAllProductFeedSubmit_result:
24734 
  """
24735 
  Attributes:
24736 
   - success
24737 
   - cex
24738 
  """
24739 
 
24740 
  thrift_spec = (
24741 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24742 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24743 
  )
24744 
 
24745 
  def __init__(self, success=None, cex=None,):
24746 
    self.success = success
24747 
    self.cex = cex
24748 
 
24749 
  def read(self, iprot):
24750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24752 
      return
24753 
    iprot.readStructBegin()
24754 
    while True:
24755 
      (fname, ftype, fid) = iprot.readFieldBegin()
24756 
      if ftype == TType.STOP:
24757 
        break
24758 
      if fid == 0:
24759 
        if ftype == TType.LIST:
24760 
          self.success = []
24761 
          (_etype551, _size548) = iprot.readListBegin()
24762 
          for _i552 in xrange(_size548):
24763 
            _elem553 = ProductFeedSubmit()
24764 
            _elem553.read(iprot)
24765 
            self.success.append(_elem553)
24766 
          iprot.readListEnd()
24767 
        else:
24768 
          iprot.skip(ftype)
24769 
      elif fid == 1:
24770 
        if ftype == TType.STRUCT:
24771 
          self.cex = CatalogServiceException()
24772 
          self.cex.read(iprot)
24773 
        else:
24774 
          iprot.skip(ftype)
24775 
      else:
24776 
        iprot.skip(ftype)
24777 
      iprot.readFieldEnd()
24778 
    iprot.readStructEnd()
24779 
 
24780 
  def write(self, oprot):
24781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24783 
      return
24784 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24785 
    if self.success is not None:
24786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24788 
      for iter554 in self.success:
24789 
        iter554.write(oprot)
24790 
      oprot.writeListEnd()
24791 
      oprot.writeFieldEnd()
24792 
    if self.cex is not None:
24793 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24794 
      self.cex.write(oprot)
24795 
      oprot.writeFieldEnd()
24796 
    oprot.writeFieldStop()
24797 
    oprot.writeStructEnd()
24798 
 
24799 
  def validate(self):
24800 
    return
24801 
 
24802 
 
24803 
  def __repr__(self):
24804 
    L = ['%s=%r' % (key, value)
24805 
      for key, value in self.__dict__.iteritems()]
24806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24807 
 
24808 
  def __eq__(self, other):
24809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24810 
 
24811 
  def __ne__(self, other):
24812 
    return not (self == other)
9724 kshitij.so 24813 
 
24814 
class getMarketplacedetailsForItem_args:
24815 
  """
24816 
  Attributes:
24817 
   - itemId
24818 
   - sourceId
24819 
  """
24820 
 
24821 
  thrift_spec = (
24822 
    None, # 0
24823 
    (1, TType.I64, 'itemId', None, None, ), # 1
24824 
    (2, TType.I64, 'sourceId', None, None, ), # 2
24825 
  )
24826 
 
24827 
  def __init__(self, itemId=None, sourceId=None,):
24828 
    self.itemId = itemId
24829 
    self.sourceId = sourceId
24830 
 
24831 
  def read(self, iprot):
24832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24834 
      return
24835 
    iprot.readStructBegin()
24836 
    while True:
24837 
      (fname, ftype, fid) = iprot.readFieldBegin()
24838 
      if ftype == TType.STOP:
24839 
        break
24840 
      if fid == 1:
24841 
        if ftype == TType.I64:
24842 
          self.itemId = iprot.readI64();
24843 
        else:
24844 
          iprot.skip(ftype)
24845 
      elif fid == 2:
24846 
        if ftype == TType.I64:
24847 
          self.sourceId = iprot.readI64();
24848 
        else:
24849 
          iprot.skip(ftype)
24850 
      else:
24851 
        iprot.skip(ftype)
24852 
      iprot.readFieldEnd()
24853 
    iprot.readStructEnd()
24854 
 
24855 
  def write(self, oprot):
24856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24858 
      return
24859 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
24860 
    if self.itemId is not None:
24861 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24862 
      oprot.writeI64(self.itemId)
24863 
      oprot.writeFieldEnd()
24864 
    if self.sourceId is not None:
24865 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
24866 
      oprot.writeI64(self.sourceId)
24867 
      oprot.writeFieldEnd()
24868 
    oprot.writeFieldStop()
24869 
    oprot.writeStructEnd()
24870 
 
24871 
  def validate(self):
24872 
    return
24873 
 
24874 
 
24875 
  def __repr__(self):
24876 
    L = ['%s=%r' % (key, value)
24877 
      for key, value in self.__dict__.iteritems()]
24878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24879 
 
24880 
  def __eq__(self, other):
24881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24882 
 
24883 
  def __ne__(self, other):
24884 
    return not (self == other)
24885 
 
24886 
class getMarketplacedetailsForItem_result:
24887 
  """
24888 
  Attributes:
24889 
   - success
24890 
  """
24891 
 
24892 
  thrift_spec = (
24893 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
24894 
  )
24895 
 
24896 
  def __init__(self, success=None,):
24897 
    self.success = success
24898 
 
24899 
  def read(self, iprot):
24900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24902 
      return
24903 
    iprot.readStructBegin()
24904 
    while True:
24905 
      (fname, ftype, fid) = iprot.readFieldBegin()
24906 
      if ftype == TType.STOP:
24907 
        break
24908 
      if fid == 0:
24909 
        if ftype == TType.STRUCT:
24910 
          self.success = MarketplaceItems()
24911 
          self.success.read(iprot)
24912 
        else:
24913 
          iprot.skip(ftype)
24914 
      else:
24915 
        iprot.skip(ftype)
24916 
      iprot.readFieldEnd()
24917 
    iprot.readStructEnd()
24918 
 
24919 
  def write(self, oprot):
24920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24922 
      return
24923 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
24924 
    if self.success is not None:
24925 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24926 
      self.success.write(oprot)
24927 
      oprot.writeFieldEnd()
24928 
    oprot.writeFieldStop()
24929 
    oprot.writeStructEnd()
24930 
 
24931 
  def validate(self):
24932 
    return
24933 
 
24934 
 
24935 
  def __repr__(self):
24936 
    L = ['%s=%r' % (key, value)
24937 
      for key, value in self.__dict__.iteritems()]
24938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24939 
 
24940 
  def __eq__(self, other):
24941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24942 
 
24943 
  def __ne__(self, other):
24944 
    return not (self == other)
24945 
 
24946 
class updateMarketplaceAttributesForItem_args:
24947 
  """
24948 
  Attributes:
24949 
   - marketPlaceItem
24950 
  """
24951 
 
24952 
  thrift_spec = (
24953 
    None, # 0
24954 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
24955 
  )
24956 
 
24957 
  def __init__(self, marketPlaceItem=None,):
24958 
    self.marketPlaceItem = marketPlaceItem
24959 
 
24960 
  def read(self, iprot):
24961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24963 
      return
24964 
    iprot.readStructBegin()
24965 
    while True:
24966 
      (fname, ftype, fid) = iprot.readFieldBegin()
24967 
      if ftype == TType.STOP:
24968 
        break
24969 
      if fid == 1:
24970 
        if ftype == TType.STRUCT:
24971 
          self.marketPlaceItem = MarketplaceItems()
24972 
          self.marketPlaceItem.read(iprot)
24973 
        else:
24974 
          iprot.skip(ftype)
24975 
      else:
24976 
        iprot.skip(ftype)
24977 
      iprot.readFieldEnd()
24978 
    iprot.readStructEnd()
24979 
 
24980 
  def write(self, oprot):
24981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24983 
      return
24984 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
24985 
    if self.marketPlaceItem is not None:
24986 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
24987 
      self.marketPlaceItem.write(oprot)
24988 
      oprot.writeFieldEnd()
24989 
    oprot.writeFieldStop()
24990 
    oprot.writeStructEnd()
24991 
 
24992 
  def validate(self):
24993 
    return
24994 
 
24995 
 
24996 
  def __repr__(self):
24997 
    L = ['%s=%r' % (key, value)
24998 
      for key, value in self.__dict__.iteritems()]
24999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25000 
 
25001 
  def __eq__(self, other):
25002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25003 
 
25004 
  def __ne__(self, other):
25005 
    return not (self == other)
25006 
 
25007 
class updateMarketplaceAttributesForItem_result:
25008 
  """
25009 
  Attributes:
25010 
   - success
25011 
  """
25012 
 
25013 
  thrift_spec = (
25014 
    (0, TType.BOOL, 'success', None, None, ), # 0
25015 
  )
25016 
 
25017 
  def __init__(self, success=None,):
25018 
    self.success = success
25019 
 
25020 
  def read(self, iprot):
25021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25023 
      return
25024 
    iprot.readStructBegin()
25025 
    while True:
25026 
      (fname, ftype, fid) = iprot.readFieldBegin()
25027 
      if ftype == TType.STOP:
25028 
        break
25029 
      if fid == 0:
25030 
        if ftype == TType.BOOL:
25031 
          self.success = iprot.readBool();
25032 
        else:
25033 
          iprot.skip(ftype)
25034 
      else:
25035 
        iprot.skip(ftype)
25036 
      iprot.readFieldEnd()
25037 
    iprot.readStructEnd()
25038 
 
25039 
  def write(self, oprot):
25040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25042 
      return
25043 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25044 
    if self.success is not None:
25045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25046 
      oprot.writeBool(self.success)
25047 
      oprot.writeFieldEnd()
25048 
    oprot.writeFieldStop()
25049 
    oprot.writeStructEnd()
25050 
 
25051 
  def validate(self):
25052 
    return
25053 
 
25054 
 
25055 
  def __repr__(self):
25056 
    L = ['%s=%r' % (key, value)
25057 
      for key, value in self.__dict__.iteritems()]
25058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25059 
 
25060 
  def __eq__(self, other):
25061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25062 
 
25063 
  def __ne__(self, other):
25064 
    return not (self == other)
9776 vikram.rag 25065 
 
9779 kshitij.so 25066 
class getCostingForMarketplace_args:
25067 
  """
25068 
  Attributes:
25069 
   - source
25070 
   - item_id
25071 
  """
25072 
 
25073 
  thrift_spec = (
25074 
    None, # 0
25075 
    (1, TType.I64, 'source', None, None, ), # 1
25076 
    (2, TType.I64, 'item_id', None, None, ), # 2
25077 
  )
25078 
 
25079 
  def __init__(self, source=None, item_id=None,):
25080 
    self.source = source
25081 
    self.item_id = item_id
25082 
 
25083 
  def read(self, iprot):
25084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25086 
      return
25087 
    iprot.readStructBegin()
25088 
    while True:
25089 
      (fname, ftype, fid) = iprot.readFieldBegin()
25090 
      if ftype == TType.STOP:
25091 
        break
25092 
      if fid == 1:
25093 
        if ftype == TType.I64:
25094 
          self.source = iprot.readI64();
25095 
        else:
25096 
          iprot.skip(ftype)
25097 
      elif fid == 2:
25098 
        if ftype == TType.I64:
25099 
          self.item_id = iprot.readI64();
25100 
        else:
25101 
          iprot.skip(ftype)
25102 
      else:
25103 
        iprot.skip(ftype)
25104 
      iprot.readFieldEnd()
25105 
    iprot.readStructEnd()
25106 
 
25107 
  def write(self, oprot):
25108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25110 
      return
25111 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25112 
    if self.source is not None:
25113 
      oprot.writeFieldBegin('source', TType.I64, 1)
25114 
      oprot.writeI64(self.source)
25115 
      oprot.writeFieldEnd()
25116 
    if self.item_id is not None:
25117 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25118 
      oprot.writeI64(self.item_id)
25119 
      oprot.writeFieldEnd()
25120 
    oprot.writeFieldStop()
25121 
    oprot.writeStructEnd()
25122 
 
25123 
  def validate(self):
25124 
    return
25125 
 
25126 
 
25127 
  def __repr__(self):
25128 
    L = ['%s=%r' % (key, value)
25129 
      for key, value in self.__dict__.iteritems()]
25130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25131 
 
25132 
  def __eq__(self, other):
25133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25134 
 
25135 
  def __ne__(self, other):
25136 
    return not (self == other)
25137 
 
25138 
class getCostingForMarketplace_result:
25139 
  """
25140 
  Attributes:
25141 
   - success
25142 
  """
25143 
 
25144 
  thrift_spec = (
25145 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25146 
  )
25147 
 
25148 
  def __init__(self, success=None,):
25149 
    self.success = success
25150 
 
25151 
  def read(self, iprot):
25152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25154 
      return
25155 
    iprot.readStructBegin()
25156 
    while True:
25157 
      (fname, ftype, fid) = iprot.readFieldBegin()
25158 
      if ftype == TType.STOP:
25159 
        break
25160 
      if fid == 0:
25161 
        if ftype == TType.STRUCT:
25162 
          self.success = MarketplacePercentage()
25163 
          self.success.read(iprot)
25164 
        else:
25165 
          iprot.skip(ftype)
25166 
      else:
25167 
        iprot.skip(ftype)
25168 
      iprot.readFieldEnd()
25169 
    iprot.readStructEnd()
25170 
 
25171 
  def write(self, oprot):
25172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25174 
      return
25175 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25176 
    if self.success is not None:
25177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25178 
      self.success.write(oprot)
25179 
      oprot.writeFieldEnd()
25180 
    oprot.writeFieldStop()
25181 
    oprot.writeStructEnd()
25182 
 
25183 
  def validate(self):
25184 
    return
25185 
 
25186 
 
25187 
  def __repr__(self):
25188 
    L = ['%s=%r' % (key, value)
25189 
      for key, value in self.__dict__.iteritems()]
25190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25191 
 
25192 
  def __eq__(self, other):
25193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25194 
 
25195 
  def __ne__(self, other):
25196 
    return not (self == other)
25197 
 
9776 vikram.rag 25198 
class getMarketPlaceItemsForPriceUpdate_args:
25199 
  """
25200 
  Attributes:
25201 
   - source
25202 
  """
25203 
 
25204 
  thrift_spec = (
25205 
    None, # 0
25206 
    (1, TType.I64, 'source', None, None, ), # 1
25207 
  )
25208 
 
25209 
  def __init__(self, source=None,):
25210 
    self.source = source
25211 
 
25212 
  def read(self, iprot):
25213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25215 
      return
25216 
    iprot.readStructBegin()
25217 
    while True:
25218 
      (fname, ftype, fid) = iprot.readFieldBegin()
25219 
      if ftype == TType.STOP:
25220 
        break
25221 
      if fid == 1:
25222 
        if ftype == TType.I64:
25223 
          self.source = iprot.readI64();
25224 
        else:
25225 
          iprot.skip(ftype)
25226 
      else:
25227 
        iprot.skip(ftype)
25228 
      iprot.readFieldEnd()
25229 
    iprot.readStructEnd()
25230 
 
25231 
  def write(self, oprot):
25232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25234 
      return
25235 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25236 
    if self.source is not None:
25237 
      oprot.writeFieldBegin('source', TType.I64, 1)
25238 
      oprot.writeI64(self.source)
25239 
      oprot.writeFieldEnd()
25240 
    oprot.writeFieldStop()
25241 
    oprot.writeStructEnd()
25242 
 
25243 
  def validate(self):
25244 
    return
25245 
 
25246 
 
25247 
  def __repr__(self):
25248 
    L = ['%s=%r' % (key, value)
25249 
      for key, value in self.__dict__.iteritems()]
25250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25251 
 
25252 
  def __eq__(self, other):
25253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25254 
 
25255 
  def __ne__(self, other):
25256 
    return not (self == other)
25257 
 
25258 
class getMarketPlaceItemsForPriceUpdate_result:
25259 
  """
25260 
  Attributes:
25261 
   - success
25262 
  """
25263 
 
25264 
  thrift_spec = (
25265 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25266 
  )
25267 
 
25268 
  def __init__(self, success=None,):
25269 
    self.success = success
25270 
 
25271 
  def read(self, iprot):
25272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25274 
      return
25275 
    iprot.readStructBegin()
25276 
    while True:
25277 
      (fname, ftype, fid) = iprot.readFieldBegin()
25278 
      if ftype == TType.STOP:
25279 
        break
25280 
      if fid == 0:
25281 
        if ftype == TType.LIST:
25282 
          self.success = []
25283 
          (_etype558, _size555) = iprot.readListBegin()
25284 
          for _i559 in xrange(_size555):
25285 
            _elem560 = MarketPlaceItemPrice()
25286 
            _elem560.read(iprot)
25287 
            self.success.append(_elem560)
25288 
          iprot.readListEnd()
25289 
        else:
25290 
          iprot.skip(ftype)
25291 
      else:
25292 
        iprot.skip(ftype)
25293 
      iprot.readFieldEnd()
25294 
    iprot.readStructEnd()
25295 
 
25296 
  def write(self, oprot):
25297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25299 
      return
25300 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25301 
    if self.success is not None:
25302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25304 
      for iter561 in self.success:
25305 
        iter561.write(oprot)
25306 
      oprot.writeListEnd()
25307 
      oprot.writeFieldEnd()
25308 
    oprot.writeFieldStop()
25309 
    oprot.writeStructEnd()
25310 
 
25311 
  def validate(self):
25312 
    return
25313 
 
25314 
 
25315 
  def __repr__(self):
25316 
    L = ['%s=%r' % (key, value)
25317 
      for key, value in self.__dict__.iteritems()]
25318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25319 
 
25320 
  def __eq__(self, other):
25321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25322 
 
25323 
  def __ne__(self, other):
25324 
    return not (self == other)
25325 
 
25326 
class updateMarketPlacePriceUpdateStatus_args:
25327 
  """
25328 
  Attributes:
25329 
   - skulist
25330 
   - timestamp
9816 kshitij.so 25331 
   - source
9776 vikram.rag 25332 
  """
25333 
 
25334 
  thrift_spec = (
25335 
    None, # 0
25336 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25337 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25338 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25339 
  )
25340 
 
9816 kshitij.so 25341 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25342 
    self.skulist = skulist
25343 
    self.timestamp = timestamp
9816 kshitij.so 25344 
    self.source = source
9776 vikram.rag 25345 
 
25346 
  def read(self, iprot):
25347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25349 
      return
25350 
    iprot.readStructBegin()
25351 
    while True:
25352 
      (fname, ftype, fid) = iprot.readFieldBegin()
25353 
      if ftype == TType.STOP:
25354 
        break
25355 
      if fid == 1:
25356 
        if ftype == TType.LIST:
25357 
          self.skulist = []
25358 
          (_etype565, _size562) = iprot.readListBegin()
25359 
          for _i566 in xrange(_size562):
25360 
            _elem567 = iprot.readI64();
25361 
            self.skulist.append(_elem567)
25362 
          iprot.readListEnd()
25363 
        else:
25364 
          iprot.skip(ftype)
25365 
      elif fid == 2:
25366 
        if ftype == TType.I64:
25367 
          self.timestamp = iprot.readI64();
25368 
        else:
25369 
          iprot.skip(ftype)
9816 kshitij.so 25370 
      elif fid == 3:
25371 
        if ftype == TType.I64:
25372 
          self.source = iprot.readI64();
25373 
        else:
25374 
          iprot.skip(ftype)
9776 vikram.rag 25375 
      else:
25376 
        iprot.skip(ftype)
25377 
      iprot.readFieldEnd()
25378 
    iprot.readStructEnd()
25379 
 
25380 
  def write(self, oprot):
25381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25383 
      return
25384 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25385 
    if self.skulist is not None:
25386 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25387 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25388 
      for iter568 in self.skulist:
25389 
        oprot.writeI64(iter568)
25390 
      oprot.writeListEnd()
25391 
      oprot.writeFieldEnd()
25392 
    if self.timestamp is not None:
25393 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25394 
      oprot.writeI64(self.timestamp)
25395 
      oprot.writeFieldEnd()
9816 kshitij.so 25396 
    if self.source is not None:
25397 
      oprot.writeFieldBegin('source', TType.I64, 3)
25398 
      oprot.writeI64(self.source)
25399 
      oprot.writeFieldEnd()
9776 vikram.rag 25400 
    oprot.writeFieldStop()
25401 
    oprot.writeStructEnd()
25402 
 
25403 
  def validate(self):
25404 
    return
25405 
 
25406 
 
25407 
  def __repr__(self):
25408 
    L = ['%s=%r' % (key, value)
25409 
      for key, value in self.__dict__.iteritems()]
25410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25411 
 
25412 
  def __eq__(self, other):
25413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25414 
 
25415 
  def __ne__(self, other):
25416 
    return not (self == other)
25417 
 
25418 
class updateMarketPlacePriceUpdateStatus_result:
25419 
 
25420 
  thrift_spec = (
25421 
  )
25422 
 
25423 
  def read(self, iprot):
25424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25426 
      return
25427 
    iprot.readStructBegin()
25428 
    while True:
25429 
      (fname, ftype, fid) = iprot.readFieldBegin()
25430 
      if ftype == TType.STOP:
25431 
        break
25432 
      else:
25433 
        iprot.skip(ftype)
25434 
      iprot.readFieldEnd()
25435 
    iprot.readStructEnd()
25436 
 
25437 
  def write(self, oprot):
25438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25440 
      return
25441 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25442 
    oprot.writeFieldStop()
25443 
    oprot.writeStructEnd()
25444 
 
25445 
  def validate(self):
25446 
    return
25447 
 
25448 
 
25449 
  def __repr__(self):
25450 
    L = ['%s=%r' % (key, value)
25451 
      for key, value in self.__dict__.iteritems()]
25452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25453 
 
25454 
  def __eq__(self, other):
25455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25456 
 
25457 
  def __ne__(self, other):
25458 
    return not (self == other)
9861 rajveer 25459 
 
25460 
class updateItemHoldInventory_args:
25461 
  """
25462 
  Attributes:
25463 
   - itemHoldMap
25464 
  """
25465 
 
25466 
  thrift_spec = (
25467 
    None, # 0
25468 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
25469 
  )
25470 
 
25471 
  def __init__(self, itemHoldMap=None,):
25472 
    self.itemHoldMap = itemHoldMap
25473 
 
25474 
  def read(self, iprot):
25475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25477 
      return
25478 
    iprot.readStructBegin()
25479 
    while True:
25480 
      (fname, ftype, fid) = iprot.readFieldBegin()
25481 
      if ftype == TType.STOP:
25482 
        break
25483 
      if fid == 1:
25484 
        if ftype == TType.MAP:
25485 
          self.itemHoldMap = {}
25486 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
25487 
          for _i573 in xrange(_size569):
25488 
            _key574 = iprot.readI64();
25489 
            _val575 = iprot.readI64();
25490 
            self.itemHoldMap[_key574] = _val575
25491 
          iprot.readMapEnd()
25492 
        else:
25493 
          iprot.skip(ftype)
25494 
      else:
25495 
        iprot.skip(ftype)
25496 
      iprot.readFieldEnd()
25497 
    iprot.readStructEnd()
25498 
 
25499 
  def write(self, oprot):
25500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25502 
      return
25503 
    oprot.writeStructBegin('updateItemHoldInventory_args')
25504 
    if self.itemHoldMap is not None:
25505 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
25506 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
25507 
      for kiter576,viter577 in self.itemHoldMap.items():
25508 
        oprot.writeI64(kiter576)
25509 
        oprot.writeI64(viter577)
25510 
      oprot.writeMapEnd()
25511 
      oprot.writeFieldEnd()
25512 
    oprot.writeFieldStop()
25513 
    oprot.writeStructEnd()
25514 
 
25515 
  def validate(self):
25516 
    return
25517 
 
25518 
 
25519 
  def __repr__(self):
25520 
    L = ['%s=%r' % (key, value)
25521 
      for key, value in self.__dict__.iteritems()]
25522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25523 
 
25524 
  def __eq__(self, other):
25525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25526 
 
25527 
  def __ne__(self, other):
25528 
    return not (self == other)
25529 
 
25530 
class updateItemHoldInventory_result:
25531 
 
25532 
  thrift_spec = (
25533 
  )
25534 
 
25535 
  def read(self, iprot):
25536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25538 
      return
25539 
    iprot.readStructBegin()
25540 
    while True:
25541 
      (fname, ftype, fid) = iprot.readFieldBegin()
25542 
      if ftype == TType.STOP:
25543 
        break
25544 
      else:
25545 
        iprot.skip(ftype)
25546 
      iprot.readFieldEnd()
25547 
    iprot.readStructEnd()
25548 
 
25549 
  def write(self, oprot):
25550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25552 
      return
25553 
    oprot.writeStructBegin('updateItemHoldInventory_result')
25554 
    oprot.writeFieldStop()
25555 
    oprot.writeStructEnd()
25556 
 
25557 
  def validate(self):
25558 
    return
25559 
 
25560 
 
25561 
  def __repr__(self):
25562 
    L = ['%s=%r' % (key, value)
25563 
      for key, value in self.__dict__.iteritems()]
25564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25565 
 
25566 
  def __eq__(self, other):
25567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25568 
 
25569 
  def __ne__(self, other):
25570 
    return not (self == other)
9895 vikram.rag 25571 
 
25572 
class updateNlcAtMarketplaces_args:
25573 
  """
25574 
  Attributes:
25575 
   - item_id
25576 
   - vendor_id
25577 
   - nlc
25578 
  """
25579 
 
25580 
  thrift_spec = None
25581 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
25582 
    self.item_id = item_id
25583 
    self.vendor_id = vendor_id
25584 
    self.nlc = nlc
25585 
 
25586 
  def read(self, iprot):
25587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25589 
      return
25590 
    iprot.readStructBegin()
25591 
    while True:
25592 
      (fname, ftype, fid) = iprot.readFieldBegin()
25593 
      if ftype == TType.STOP:
25594 
        break
25595 
      if fid == 1:
25596 
        if ftype == TType.I64:
25597 
          self.item_id = iprot.readI64();
25598 
        else:
25599 
          iprot.skip(ftype)
25600 
      elif fid == 2:
25601 
        if ftype == TType.I64:
25602 
          self.vendor_id = iprot.readI64();
25603 
        else:
25604 
          iprot.skip(ftype)
25605 
      elif fid == -1:
25606 
        if ftype == TType.DOUBLE:
25607 
          self.nlc = iprot.readDouble();
25608 
        else:
25609 
          iprot.skip(ftype)
25610 
      else:
25611 
        iprot.skip(ftype)
25612 
      iprot.readFieldEnd()
25613 
    iprot.readStructEnd()
25614 
 
25615 
  def write(self, oprot):
25616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25618 
      return
25619 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
25620 
    if self.nlc is not None:
25621 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
25622 
      oprot.writeDouble(self.nlc)
25623 
      oprot.writeFieldEnd()
25624 
    if self.item_id is not None:
25625 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25626 
      oprot.writeI64(self.item_id)
25627 
      oprot.writeFieldEnd()
25628 
    if self.vendor_id is not None:
25629 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
25630 
      oprot.writeI64(self.vendor_id)
25631 
      oprot.writeFieldEnd()
25632 
    oprot.writeFieldStop()
25633 
    oprot.writeStructEnd()
25634 
 
25635 
  def validate(self):
25636 
    return
25637 
 
25638 
 
25639 
  def __repr__(self):
25640 
    L = ['%s=%r' % (key, value)
25641 
      for key, value in self.__dict__.iteritems()]
25642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25643 
 
25644 
  def __eq__(self, other):
25645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25646 
 
25647 
  def __ne__(self, other):
25648 
    return not (self == other)
25649 
 
25650 
class updateNlcAtMarketplaces_result:
25651 
 
25652 
  thrift_spec = (
25653 
  )
25654 
 
25655 
  def read(self, iprot):
25656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25658 
      return
25659 
    iprot.readStructBegin()
25660 
    while True:
25661 
      (fname, ftype, fid) = iprot.readFieldBegin()
25662 
      if ftype == TType.STOP:
25663 
        break
25664 
      else:
25665 
        iprot.skip(ftype)
25666 
      iprot.readFieldEnd()
25667 
    iprot.readStructEnd()
25668 
 
25669 
  def write(self, oprot):
25670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25672 
      return
25673 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
25674 
    oprot.writeFieldStop()
25675 
    oprot.writeStructEnd()
25676 
 
25677 
  def validate(self):
25678 
    return
25679 
 
25680 
 
25681 
  def __repr__(self):
25682 
    L = ['%s=%r' % (key, value)
25683 
      for key, value in self.__dict__.iteritems()]
25684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25685 
 
25686 
  def __eq__(self, other):
25687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25688 
 
25689 
  def __ne__(self, other):
25690 
    return not (self == other)