Subversion Repositories SmartDukaan

Rev

Rev 9779 | Rev 9861 | 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 
 
1037 
 
5944 mandeep.dh 1038 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1039 
  def __init__(self, iprot, oprot=None):
1040 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1041 
 
1042 
  def addItem(self, item):
1043 
    """
1044 
    Availability and inventory attributes
1045 
 
1046 
    Parameters:
1047 
     - item
1048 
    """
1049 
    self.send_addItem(item)
1050 
    return self.recv_addItem()
1051 
 
1052 
  def send_addItem(self, item):
1053 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1054 
    args = addItem_args()
1055 
    args.item = item
1056 
    args.write(self._oprot)
1057 
    self._oprot.writeMessageEnd()
1058 
    self._oprot.trans.flush()
1059 
 
1060 
  def recv_addItem(self, ):
1061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1062 
    if mtype == TMessageType.EXCEPTION:
1063 
      x = TApplicationException()
1064 
      x.read(self._iprot)
1065 
      self._iprot.readMessageEnd()
1066 
      raise x
1067 
    result = addItem_result()
1068 
    result.read(self._iprot)
1069 
    self._iprot.readMessageEnd()
1070 
    if result.success is not None:
1071 
      return result.success
1072 
    if result.cex is not None:
1073 
      raise result.cex
1074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1075 
 
1076 
  def updateItem(self, item):
1077 
    """
1078 
    Parameters:
1079 
     - item
1080 
    """
1081 
    self.send_updateItem(item)
1082 
    return self.recv_updateItem()
1083 
 
1084 
  def send_updateItem(self, item):
1085 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1086 
    args = updateItem_args()
1087 
    args.item = item
1088 
    args.write(self._oprot)
1089 
    self._oprot.writeMessageEnd()
1090 
    self._oprot.trans.flush()
1091 
 
1092 
  def recv_updateItem(self, ):
1093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1094 
    if mtype == TMessageType.EXCEPTION:
1095 
      x = TApplicationException()
1096 
      x.read(self._iprot)
1097 
      self._iprot.readMessageEnd()
1098 
      raise x
1099 
    result = updateItem_result()
1100 
    result.read(self._iprot)
1101 
    self._iprot.readMessageEnd()
1102 
    if result.success is not None:
1103 
      return result.success
1104 
    if result.cex is not None:
1105 
      raise result.cex
1106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1107 
 
1108 
  def isActive(self, itemId):
1109 
    """
1110 
    Checks if the item given to the corresponding itemId is active. If it's active,
1111 
    whether it's risky and if it's risky, its inventory position.
1112 
 
1113 
    Parameters:
1114 
     - itemId
1115 
    """
1116 
    self.send_isActive(itemId)
1117 
    return self.recv_isActive()
1118 
 
1119 
  def send_isActive(self, itemId):
1120 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1121 
    args = isActive_args()
1122 
    args.itemId = itemId
1123 
    args.write(self._oprot)
1124 
    self._oprot.writeMessageEnd()
1125 
    self._oprot.trans.flush()
1126 
 
1127 
  def recv_isActive(self, ):
1128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1129 
    if mtype == TMessageType.EXCEPTION:
1130 
      x = TApplicationException()
1131 
      x.read(self._iprot)
1132 
      self._iprot.readMessageEnd()
1133 
      raise x
1134 
    result = isActive_result()
1135 
    result.read(self._iprot)
1136 
    self._iprot.readMessageEnd()
1137 
    if result.success is not None:
1138 
      return result.success
1139 
    if result.isex is not None:
1140 
      raise result.isex
1141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1142 
 
7438 amit.gupta 1143 
  def getItemsStatus(self, itemIds):
1144 
    """
1145 
    Parameters:
1146 
     - itemIds
1147 
    """
1148 
    self.send_getItemsStatus(itemIds)
1149 
    return self.recv_getItemsStatus()
1150 
 
1151 
  def send_getItemsStatus(self, itemIds):
1152 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1153 
    args = getItemsStatus_args()
1154 
    args.itemIds = itemIds
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_getItemsStatus(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = getItemsStatus_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.success is not None:
1170 
      return result.success
1171 
    if result.isex is not None:
1172 
      raise result.isex
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1174 
 
5944 mandeep.dh 1175 
  def getItemStatusDescription(self, itemId):
1176 
    """
1177 
    Parameters:
1178 
     - itemId
1179 
    """
1180 
    self.send_getItemStatusDescription(itemId)
1181 
    return self.recv_getItemStatusDescription()
1182 
 
1183 
  def send_getItemStatusDescription(self, itemId):
1184 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1185 
    args = getItemStatusDescription_args()
1186 
    args.itemId = itemId
1187 
    args.write(self._oprot)
1188 
    self._oprot.writeMessageEnd()
1189 
    self._oprot.trans.flush()
1190 
 
1191 
  def recv_getItemStatusDescription(self, ):
1192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1193 
    if mtype == TMessageType.EXCEPTION:
1194 
      x = TApplicationException()
1195 
      x.read(self._iprot)
1196 
      self._iprot.readMessageEnd()
1197 
      raise x
1198 
    result = getItemStatusDescription_result()
1199 
    result.read(self._iprot)
1200 
    self._iprot.readMessageEnd()
1201 
    if result.success is not None:
1202 
      return result.success
1203 
    if result.isex is not None:
1204 
      raise result.isex
1205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1206 
 
1207 
  def startItemOn(self, item_id, timestamp):
1208 
    """
1209 
    Parameters:
1210 
     - item_id
1211 
     - timestamp
1212 
    """
1213 
    self.send_startItemOn(item_id, timestamp)
1214 
    self.recv_startItemOn()
1215 
 
1216 
  def send_startItemOn(self, item_id, timestamp):
1217 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1218 
    args = startItemOn_args()
1219 
    args.item_id = item_id
1220 
    args.timestamp = timestamp
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_startItemOn(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = startItemOn_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
1235 
    if result.cex is not None:
1236 
      raise result.cex
1237 
    return
1238 
 
1239 
  def retireItemOn(self, item_id, timestamp):
1240 
    """
1241 
    Parameters:
1242 
     - item_id
1243 
     - timestamp
1244 
    """
1245 
    self.send_retireItemOn(item_id, timestamp)
1246 
    self.recv_retireItemOn()
1247 
 
1248 
  def send_retireItemOn(self, item_id, timestamp):
1249 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1250 
    args = retireItemOn_args()
1251 
    args.item_id = item_id
1252 
    args.timestamp = timestamp
1253 
    args.write(self._oprot)
1254 
    self._oprot.writeMessageEnd()
1255 
    self._oprot.trans.flush()
1256 
 
1257 
  def recv_retireItemOn(self, ):
1258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1259 
    if mtype == TMessageType.EXCEPTION:
1260 
      x = TApplicationException()
1261 
      x.read(self._iprot)
1262 
      self._iprot.readMessageEnd()
1263 
      raise x
1264 
    result = retireItemOn_result()
1265 
    result.read(self._iprot)
1266 
    self._iprot.readMessageEnd()
1267 
    if result.cex is not None:
1268 
      raise result.cex
1269 
    return
1270 
 
1271 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1272 
    """
1273 
    Parameters:
1274 
     - item_id
1275 
     - timestamp
1276 
     - newstatus
1277 
    """
1278 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1279 
    self.recv_changeItemStatus()
1280 
 
1281 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1282 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1283 
    args = changeItemStatus_args()
1284 
    args.item_id = item_id
1285 
    args.timestamp = timestamp
1286 
    args.newstatus = newstatus
1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_changeItemStatus(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = changeItemStatus_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
1301 
    if result.cex is not None:
1302 
      raise result.cex
1303 
    return
1304 
 
1305 
  def getItem(self, item_id):
1306 
    """
1307 
    Parameters:
1308 
     - item_id
1309 
    """
1310 
    self.send_getItem(item_id)
1311 
    return self.recv_getItem()
1312 
 
1313 
  def send_getItem(self, item_id):
1314 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1315 
    args = getItem_args()
1316 
    args.item_id = item_id
1317 
    args.write(self._oprot)
1318 
    self._oprot.writeMessageEnd()
1319 
    self._oprot.trans.flush()
1320 
 
1321 
  def recv_getItem(self, ):
1322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1323 
    if mtype == TMessageType.EXCEPTION:
1324 
      x = TApplicationException()
1325 
      x.read(self._iprot)
1326 
      self._iprot.readMessageEnd()
1327 
      raise x
1328 
    result = getItem_result()
1329 
    result.read(self._iprot)
1330 
    self._iprot.readMessageEnd()
1331 
    if result.success is not None:
1332 
      return result.success
1333 
    if result.cex is not None:
1334 
      raise result.cex
1335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1336 
 
1337 
  def getItemsByCatalogId(self, catalog_item_id):
1338 
    """
1339 
    Parameters:
1340 
     - catalog_item_id
1341 
    """
1342 
    self.send_getItemsByCatalogId(catalog_item_id)
1343 
    return self.recv_getItemsByCatalogId()
1344 
 
1345 
  def send_getItemsByCatalogId(self, catalog_item_id):
1346 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1347 
    args = getItemsByCatalogId_args()
1348 
    args.catalog_item_id = catalog_item_id
1349 
    args.write(self._oprot)
1350 
    self._oprot.writeMessageEnd()
1351 
    self._oprot.trans.flush()
1352 
 
1353 
  def recv_getItemsByCatalogId(self, ):
1354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1355 
    if mtype == TMessageType.EXCEPTION:
1356 
      x = TApplicationException()
1357 
      x.read(self._iprot)
1358 
      self._iprot.readMessageEnd()
1359 
      raise x
1360 
    result = getItemsByCatalogId_result()
1361 
    result.read(self._iprot)
1362 
    self._iprot.readMessageEnd()
1363 
    if result.success is not None:
1364 
      return result.success
1365 
    if result.cex is not None:
1366 
      raise result.cex
1367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1368 
 
1369 
  def getValidItemsByCatalogId(self, catalog_item_id):
1370 
    """
1371 
    Parameters:
1372 
     - catalog_item_id
1373 
    """
1374 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1375 
    return self.recv_getValidItemsByCatalogId()
1376 
 
1377 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1378 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1379 
    args = getValidItemsByCatalogId_args()
1380 
    args.catalog_item_id = catalog_item_id
1381 
    args.write(self._oprot)
1382 
    self._oprot.writeMessageEnd()
1383 
    self._oprot.trans.flush()
1384 
 
1385 
  def recv_getValidItemsByCatalogId(self, ):
1386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1387 
    if mtype == TMessageType.EXCEPTION:
1388 
      x = TApplicationException()
1389 
      x.read(self._iprot)
1390 
      self._iprot.readMessageEnd()
1391 
      raise x
1392 
    result = getValidItemsByCatalogId_result()
1393 
    result.read(self._iprot)
1394 
    self._iprot.readMessageEnd()
1395 
    if result.success is not None:
1396 
      return result.success
1397 
    if result.cex is not None:
1398 
      raise result.cex
1399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1400 
 
1401 
  def getAllItems(self, isActive):
1402 
    """
1403 
    Parameters:
1404 
     - isActive
1405 
    """
1406 
    self.send_getAllItems(isActive)
1407 
    return self.recv_getAllItems()
1408 
 
1409 
  def send_getAllItems(self, isActive):
1410 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1411 
    args = getAllItems_args()
1412 
    args.isActive = isActive
1413 
    args.write(self._oprot)
1414 
    self._oprot.writeMessageEnd()
1415 
    self._oprot.trans.flush()
1416 
 
1417 
  def recv_getAllItems(self, ):
1418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1419 
    if mtype == TMessageType.EXCEPTION:
1420 
      x = TApplicationException()
1421 
      x.read(self._iprot)
1422 
      self._iprot.readMessageEnd()
1423 
      raise x
1424 
    result = getAllItems_result()
1425 
    result.read(self._iprot)
1426 
    self._iprot.readMessageEnd()
1427 
    if result.success is not None:
1428 
      return result.success
1429 
    if result.cex is not None:
1430 
      raise result.cex
1431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1432 
 
1433 
  def getAllItemsByStatus(self, itemStatus):
1434 
    """
1435 
    Parameters:
1436 
     - itemStatus
1437 
    """
1438 
    self.send_getAllItemsByStatus(itemStatus)
1439 
    return self.recv_getAllItemsByStatus()
1440 
 
1441 
  def send_getAllItemsByStatus(self, itemStatus):
1442 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1443 
    args = getAllItemsByStatus_args()
1444 
    args.itemStatus = itemStatus
1445 
    args.write(self._oprot)
1446 
    self._oprot.writeMessageEnd()
1447 
    self._oprot.trans.flush()
1448 
 
1449 
  def recv_getAllItemsByStatus(self, ):
1450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1451 
    if mtype == TMessageType.EXCEPTION:
1452 
      x = TApplicationException()
1453 
      x.read(self._iprot)
1454 
      self._iprot.readMessageEnd()
1455 
      raise x
1456 
    result = getAllItemsByStatus_result()
1457 
    result.read(self._iprot)
1458 
    self._iprot.readMessageEnd()
1459 
    if result.success is not None:
1460 
      return result.success
1461 
    if result.cex is not None:
1462 
      raise result.cex
1463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1464 
 
9253 rajveer 1465 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1466 
    """
1467 
    Parameters:
1468 
     - entityId
1469 
     - category
1470 
     - brand
1471 
     - modelName
1472 
     - modelNumber
9253 rajveer 1473 
     - isAndroid
5944 mandeep.dh 1474 
    """
9253 rajveer 1475 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1476 
    return self.recv_markItemAsContentComplete()
1477 
 
9253 rajveer 1478 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1479 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1480 
    args = markItemAsContentComplete_args()
1481 
    args.entityId = entityId
1482 
    args.category = category
1483 
    args.brand = brand
1484 
    args.modelName = modelName
1485 
    args.modelNumber = modelNumber
9253 rajveer 1486 
    args.isAndroid = isAndroid
5944 mandeep.dh 1487 
    args.write(self._oprot)
1488 
    self._oprot.writeMessageEnd()
1489 
    self._oprot.trans.flush()
1490 
 
1491 
  def recv_markItemAsContentComplete(self, ):
1492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1493 
    if mtype == TMessageType.EXCEPTION:
1494 
      x = TApplicationException()
1495 
      x.read(self._iprot)
1496 
      self._iprot.readMessageEnd()
1497 
      raise x
1498 
    result = markItemAsContentComplete_result()
1499 
    result.read(self._iprot)
1500 
    self._iprot.readMessageEnd()
1501 
    if result.success is not None:
1502 
      return result.success
1503 
    if result.cex is not None:
1504 
      raise result.cex
1505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1506 
 
1507 
  def getAllItemsInRange(self, offset, limit):
1508 
    """
1509 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1510 
 
1511 
    Parameters:
1512 
     - offset
1513 
     - limit
1514 
    """
1515 
    self.send_getAllItemsInRange(offset, limit)
1516 
    return self.recv_getAllItemsInRange()
1517 
 
1518 
  def send_getAllItemsInRange(self, offset, limit):
1519 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1520 
    args = getAllItemsInRange_args()
1521 
    args.offset = offset
1522 
    args.limit = limit
1523 
    args.write(self._oprot)
1524 
    self._oprot.writeMessageEnd()
1525 
    self._oprot.trans.flush()
1526 
 
1527 
  def recv_getAllItemsInRange(self, ):
1528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1529 
    if mtype == TMessageType.EXCEPTION:
1530 
      x = TApplicationException()
1531 
      x.read(self._iprot)
1532 
      self._iprot.readMessageEnd()
1533 
      raise x
1534 
    result = getAllItemsInRange_result()
1535 
    result.read(self._iprot)
1536 
    self._iprot.readMessageEnd()
1537 
    if result.success is not None:
1538 
      return result.success
1539 
    if result.cex is not None:
1540 
      raise result.cex
1541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1542 
 
1543 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1544 
    """
1545 
    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.
1546 
 
1547 
    Parameters:
1548 
     - itemStatus
1549 
     - offset
1550 
     - limit
1551 
    """
1552 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1553 
    return self.recv_getAllItemsByStatusInRange()
1554 
 
1555 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1556 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1557 
    args = getAllItemsByStatusInRange_args()
1558 
    args.itemStatus = itemStatus
1559 
    args.offset = offset
1560 
    args.limit = limit
1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
1565 
  def recv_getAllItemsByStatusInRange(self, ):
1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
1572 
    result = getAllItemsByStatusInRange_result()
1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
1575 
    if result.success is not None:
1576 
      return result.success
1577 
    if result.cex is not None:
1578 
      raise result.cex
1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1580 
 
1581 
  def getItemCountByStatus(self, useStatus, itemStatus):
1582 
    """
1583 
    Gets a count of all items by status
1584 
 
1585 
    Parameters:
1586 
     - useStatus
1587 
     - itemStatus
1588 
    """
1589 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1590 
    return self.recv_getItemCountByStatus()
1591 
 
1592 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1593 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1594 
    args = getItemCountByStatus_args()
1595 
    args.useStatus = useStatus
1596 
    args.itemStatus = itemStatus
1597 
    args.write(self._oprot)
1598 
    self._oprot.writeMessageEnd()
1599 
    self._oprot.trans.flush()
1600 
 
1601 
  def recv_getItemCountByStatus(self, ):
1602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1603 
    if mtype == TMessageType.EXCEPTION:
1604 
      x = TApplicationException()
1605 
      x.read(self._iprot)
1606 
      self._iprot.readMessageEnd()
1607 
      raise x
1608 
    result = getItemCountByStatus_result()
1609 
    result.read(self._iprot)
1610 
    self._iprot.readMessageEnd()
1611 
    if result.success is not None:
1612 
      return result.success
1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1614 
 
1615 
  def getBestSellers(self, ):
1616 
    self.send_getBestSellers()
1617 
    return self.recv_getBestSellers()
1618 
 
1619 
  def send_getBestSellers(self, ):
1620 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1621 
    args = getBestSellers_args()
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getBestSellers(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getBestSellers_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
1636 
    if result.success is not None:
1637 
      return result.success
1638 
    if result.isex is not None:
1639 
      raise result.isex
1640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1641 
 
1642 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1643 
    """
1644 
    Parameters:
1645 
     - beginIndex
1646 
     - totalItems
1647 
     - brand
1648 
     - category
1649 
    """
1650 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1651 
    return self.recv_getBestSellersCatalogIds()
1652 
 
1653 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1654 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1655 
    args = getBestSellersCatalogIds_args()
1656 
    args.beginIndex = beginIndex
1657 
    args.totalItems = totalItems
1658 
    args.brand = brand
1659 
    args.category = category
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getBestSellersCatalogIds(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getBestSellersCatalogIds_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
1674 
    if result.success is not None:
1675 
      return result.success
1676 
    if result.cex is not None:
1677 
      raise result.cex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1679 
 
1680 
  def getBestSellersCount(self, ):
1681 
    self.send_getBestSellersCount()
1682 
    return self.recv_getBestSellersCount()
1683 
 
1684 
  def send_getBestSellersCount(self, ):
1685 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1686 
    args = getBestSellersCount_args()
1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
1691 
  def recv_getBestSellersCount(self, ):
1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
1698 
    result = getBestSellersCount_result()
1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
1701 
    if result.success is not None:
1702 
      return result.success
1703 
    if result.cex is not None:
1704 
      raise result.cex
1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1706 
 
1707 
  def getBestDeals(self, ):
1708 
    self.send_getBestDeals()
1709 
    return self.recv_getBestDeals()
1710 
 
1711 
  def send_getBestDeals(self, ):
1712 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1713 
    args = getBestDeals_args()
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_getBestDeals(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = getBestDeals_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
1728 
    if result.success is not None:
1729 
      return result.success
1730 
    if result.isex is not None:
1731 
      raise result.isex
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1733 
 
1734 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1735 
    """
1736 
    Parameters:
1737 
     - beginIndex
1738 
     - totalItems
1739 
     - brand
1740 
     - category
1741 
    """
1742 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1743 
    return self.recv_getBestDealsCatalogIds()
1744 
 
1745 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1746 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1747 
    args = getBestDealsCatalogIds_args()
1748 
    args.beginIndex = beginIndex
1749 
    args.totalItems = totalItems
1750 
    args.brand = brand
1751 
    args.category = category
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_getBestDealsCatalogIds(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = getBestDealsCatalogIds_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
1766 
    if result.success is not None:
1767 
      return result.success
1768 
    if result.cex is not None:
1769 
      raise result.cex
1770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1771 
 
1772 
  def getBestDealsCount(self, ):
1773 
    self.send_getBestDealsCount()
1774 
    return self.recv_getBestDealsCount()
1775 
 
1776 
  def send_getBestDealsCount(self, ):
1777 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1778 
    args = getBestDealsCount_args()
1779 
    args.write(self._oprot)
1780 
    self._oprot.writeMessageEnd()
1781 
    self._oprot.trans.flush()
1782 
 
1783 
  def recv_getBestDealsCount(self, ):
1784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1785 
    if mtype == TMessageType.EXCEPTION:
1786 
      x = TApplicationException()
1787 
      x.read(self._iprot)
1788 
      self._iprot.readMessageEnd()
1789 
      raise x
1790 
    result = getBestDealsCount_result()
1791 
    result.read(self._iprot)
1792 
    self._iprot.readMessageEnd()
1793 
    if result.success is not None:
1794 
      return result.success
1795 
    if result.cex is not None:
1796 
      raise result.cex
1797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1798 
 
1799 
  def getComingSoon(self, ):
1800 
    self.send_getComingSoon()
1801 
    return self.recv_getComingSoon()
1802 
 
1803 
  def send_getComingSoon(self, ):
1804 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1805 
    args = getComingSoon_args()
1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
1810 
  def recv_getComingSoon(self, ):
1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
1817 
    result = getComingSoon_result()
1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
1820 
    if result.success is not None:
1821 
      return result.success
1822 
    if result.isex is not None:
1823 
      raise result.isex
1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1825 
 
1826 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1827 
    """
1828 
    Parameters:
1829 
     - beginIndex
1830 
     - totalItems
1831 
     - brand
1832 
     - category
1833 
    """
1834 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1835 
    return self.recv_getComingSoonCatalogIds()
1836 
 
1837 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1838 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1839 
    args = getComingSoonCatalogIds_args()
1840 
    args.beginIndex = beginIndex
1841 
    args.totalItems = totalItems
1842 
    args.brand = brand
1843 
    args.category = category
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getComingSoonCatalogIds(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getComingSoonCatalogIds_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
1858 
    if result.success is not None:
1859 
      return result.success
1860 
    if result.cex is not None:
1861 
      raise result.cex
1862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1863 
 
1864 
  def getComingSoonCount(self, ):
1865 
    self.send_getComingSoonCount()
1866 
    return self.recv_getComingSoonCount()
1867 
 
1868 
  def send_getComingSoonCount(self, ):
1869 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1870 
    args = getComingSoonCount_args()
1871 
    args.write(self._oprot)
1872 
    self._oprot.writeMessageEnd()
1873 
    self._oprot.trans.flush()
1874 
 
1875 
  def recv_getComingSoonCount(self, ):
1876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1877 
    if mtype == TMessageType.EXCEPTION:
1878 
      x = TApplicationException()
1879 
      x.read(self._iprot)
1880 
      self._iprot.readMessageEnd()
1881 
      raise x
1882 
    result = getComingSoonCount_result()
1883 
    result.read(self._iprot)
1884 
    self._iprot.readMessageEnd()
1885 
    if result.success is not None:
1886 
      return result.success
1887 
    if result.cex is not None:
1888 
      raise result.cex
1889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1890 
 
1891 
  def getLatestArrivals(self, ):
1892 
    """
1893 
    Returns a list of items sorted in the descending order by start date.
1894 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1895 
    """
1896 
    self.send_getLatestArrivals()
1897 
    return self.recv_getLatestArrivals()
1898 
 
1899 
  def send_getLatestArrivals(self, ):
1900 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1901 
    args = getLatestArrivals_args()
1902 
    args.write(self._oprot)
1903 
    self._oprot.writeMessageEnd()
1904 
    self._oprot.trans.flush()
1905 
 
1906 
  def recv_getLatestArrivals(self, ):
1907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1908 
    if mtype == TMessageType.EXCEPTION:
1909 
      x = TApplicationException()
1910 
      x.read(self._iprot)
1911 
      self._iprot.readMessageEnd()
1912 
      raise x
1913 
    result = getLatestArrivals_result()
1914 
    result.read(self._iprot)
1915 
    self._iprot.readMessageEnd()
1916 
    if result.success is not None:
1917 
      return result.success
1918 
    if result.isex is not None:
1919 
      raise result.isex
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1921 
 
1922 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1923 
    """
1924 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1925 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1926 
 
1927 
    Parameters:
1928 
     - beginIndex
1929 
     - totalItems
1930 
     - brand
1931 
     - categories
1932 
    """
1933 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1934 
    return self.recv_getLatestArrivalsCatalogIds()
1935 
 
1936 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1937 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1938 
    args = getLatestArrivalsCatalogIds_args()
1939 
    args.beginIndex = beginIndex
1940 
    args.totalItems = totalItems
1941 
    args.brand = brand
1942 
    args.categories = categories
1943 
    args.write(self._oprot)
1944 
    self._oprot.writeMessageEnd()
1945 
    self._oprot.trans.flush()
1946 
 
1947 
  def recv_getLatestArrivalsCatalogIds(self, ):
1948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1949 
    if mtype == TMessageType.EXCEPTION:
1950 
      x = TApplicationException()
1951 
      x.read(self._iprot)
1952 
      self._iprot.readMessageEnd()
1953 
      raise x
1954 
    result = getLatestArrivalsCatalogIds_result()
1955 
    result.read(self._iprot)
1956 
    self._iprot.readMessageEnd()
1957 
    if result.success is not None:
1958 
      return result.success
1959 
    if result.cex is not None:
1960 
      raise result.cex
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1962 
 
1963 
  def getLatestArrivalsCount(self, ):
1964 
    """
1965 
    Get the total number of latest arrivals we are willing to show.
1966 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1967 
    """
1968 
    self.send_getLatestArrivalsCount()
1969 
    return self.recv_getLatestArrivalsCount()
1970 
 
1971 
  def send_getLatestArrivalsCount(self, ):
1972 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1973 
    args = getLatestArrivalsCount_args()
1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
1978 
  def recv_getLatestArrivalsCount(self, ):
1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
1985 
    result = getLatestArrivalsCount_result()
1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
1988 
    if result.success is not None:
1989 
      return result.success
1990 
    if result.cex is not None:
1991 
      raise result.cex
1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1993 
 
1994 
  def generateNewEntityID(self, ):
1995 
    self.send_generateNewEntityID()
1996 
    return self.recv_generateNewEntityID()
1997 
 
1998 
  def send_generateNewEntityID(self, ):
1999 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2000 
    args = generateNewEntityID_args()
2001 
    args.write(self._oprot)
2002 
    self._oprot.writeMessageEnd()
2003 
    self._oprot.trans.flush()
2004 
 
2005 
  def recv_generateNewEntityID(self, ):
2006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2007 
    if mtype == TMessageType.EXCEPTION:
2008 
      x = TApplicationException()
2009 
      x.read(self._iprot)
2010 
      self._iprot.readMessageEnd()
2011 
      raise x
2012 
    result = generateNewEntityID_result()
2013 
    result.read(self._iprot)
2014 
    self._iprot.readMessageEnd()
2015 
    if result.success is not None:
2016 
      return result.success
2017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2018 
 
2019 
  def addCategory(self, category):
2020 
    """
2021 
    All category related functions
2022 
 
2023 
    Parameters:
2024 
     - category
2025 
    """
2026 
    self.send_addCategory(category)
2027 
    return self.recv_addCategory()
2028 
 
2029 
  def send_addCategory(self, category):
2030 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2031 
    args = addCategory_args()
2032 
    args.category = category
2033 
    args.write(self._oprot)
2034 
    self._oprot.writeMessageEnd()
2035 
    self._oprot.trans.flush()
2036 
 
2037 
  def recv_addCategory(self, ):
2038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2039 
    if mtype == TMessageType.EXCEPTION:
2040 
      x = TApplicationException()
2041 
      x.read(self._iprot)
2042 
      self._iprot.readMessageEnd()
2043 
      raise x
2044 
    result = addCategory_result()
2045 
    result.read(self._iprot)
2046 
    self._iprot.readMessageEnd()
2047 
    if result.success is not None:
2048 
      return result.success
2049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2050 
 
2051 
  def getCategory(self, id):
2052 
    """
2053 
    Parameters:
2054 
     - id
2055 
    """
2056 
    self.send_getCategory(id)
2057 
    return self.recv_getCategory()
2058 
 
2059 
  def send_getCategory(self, id):
2060 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2061 
    args = getCategory_args()
2062 
    args.id = id
2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
2067 
  def recv_getCategory(self, ):
2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
2074 
    result = getCategory_result()
2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
2077 
    if result.success is not None:
2078 
      return result.success
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2080 
 
2081 
  def getAllCategories(self, ):
2082 
    self.send_getAllCategories()
2083 
    return self.recv_getAllCategories()
2084 
 
2085 
  def send_getAllCategories(self, ):
2086 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2087 
    args = getAllCategories_args()
2088 
    args.write(self._oprot)
2089 
    self._oprot.writeMessageEnd()
2090 
    self._oprot.trans.flush()
2091 
 
2092 
  def recv_getAllCategories(self, ):
2093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2094 
    if mtype == TMessageType.EXCEPTION:
2095 
      x = TApplicationException()
2096 
      x.read(self._iprot)
2097 
      self._iprot.readMessageEnd()
2098 
      raise x
2099 
    result = getAllCategories_result()
2100 
    result.read(self._iprot)
2101 
    self._iprot.readMessageEnd()
2102 
    if result.success is not None:
2103 
      return result.success
2104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2105 
 
2106 
  def getAllSimilarItems(self, itemId):
2107 
    """
2108 
    Returns the list of similar items.
2109 
 
2110 
    Parameters:
2111 
     - itemId
2112 
    """
2113 
    self.send_getAllSimilarItems(itemId)
2114 
    return self.recv_getAllSimilarItems()
2115 
 
2116 
  def send_getAllSimilarItems(self, itemId):
2117 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2118 
    args = getAllSimilarItems_args()
2119 
    args.itemId = itemId
2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
2124 
  def recv_getAllSimilarItems(self, ):
2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
2131 
    result = getAllSimilarItems_result()
2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
2134 
    if result.success is not None:
2135 
      return result.success
2136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2137 
 
2138 
  def addSimilarItem(self, itemId, catalogItemId):
2139 
    """
2140 
    Adds similar item.
2141 
 
2142 
    Parameters:
2143 
     - itemId
2144 
     - catalogItemId
2145 
    """
2146 
    self.send_addSimilarItem(itemId, catalogItemId)
2147 
    return self.recv_addSimilarItem()
2148 
 
2149 
  def send_addSimilarItem(self, itemId, catalogItemId):
2150 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2151 
    args = addSimilarItem_args()
2152 
    args.itemId = itemId
2153 
    args.catalogItemId = catalogItemId
2154 
    args.write(self._oprot)
2155 
    self._oprot.writeMessageEnd()
2156 
    self._oprot.trans.flush()
2157 
 
2158 
  def recv_addSimilarItem(self, ):
2159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2160 
    if mtype == TMessageType.EXCEPTION:
2161 
      x = TApplicationException()
2162 
      x.read(self._iprot)
2163 
      self._iprot.readMessageEnd()
2164 
      raise x
2165 
    result = addSimilarItem_result()
2166 
    result.read(self._iprot)
2167 
    self._iprot.readMessageEnd()
2168 
    if result.success is not None:
2169 
      return result.success
2170 
    if result.cex is not None:
2171 
      raise result.cex
2172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2173 
 
6512 kshitij.so 2174 
  def addTag(self, displayName, itemId):
2175 
    """
2176 
    Tag Related
2177 
 
2178 
    Parameters:
2179 
     - displayName
2180 
     - itemId
2181 
    """
2182 
    self.send_addTag(displayName, itemId)
2183 
    return self.recv_addTag()
2184 
 
2185 
  def send_addTag(self, displayName, itemId):
2186 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2187 
    args = addTag_args()
2188 
    args.displayName = displayName
2189 
    args.itemId = itemId
2190 
    args.write(self._oprot)
2191 
    self._oprot.writeMessageEnd()
2192 
    self._oprot.trans.flush()
2193 
 
2194 
  def recv_addTag(self, ):
2195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2196 
    if mtype == TMessageType.EXCEPTION:
2197 
      x = TApplicationException()
2198 
      x.read(self._iprot)
2199 
      self._iprot.readMessageEnd()
2200 
      raise x
2201 
    result = addTag_result()
2202 
    result.read(self._iprot)
2203 
    self._iprot.readMessageEnd()
2204 
    if result.success is not None:
2205 
      return result.success
2206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2207 
 
2208 
  def deleteEntityTag(self, displayName, itemId):
2209 
    """
2210 
    Parameters:
2211 
     - displayName
2212 
     - itemId
2213 
    """
2214 
    self.send_deleteEntityTag(displayName, itemId)
2215 
    return self.recv_deleteEntityTag()
2216 
 
2217 
  def send_deleteEntityTag(self, displayName, itemId):
2218 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2219 
    args = deleteEntityTag_args()
2220 
    args.displayName = displayName
2221 
    args.itemId = itemId
2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
2226 
  def recv_deleteEntityTag(self, ):
2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
2233 
    result = deleteEntityTag_result()
2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
2236 
    if result.success is not None:
2237 
      return result.success
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2239 
 
2240 
  def deleteTag(self, displayName):
2241 
    """
2242 
    Parameters:
2243 
     - displayName
2244 
    """
2245 
    self.send_deleteTag(displayName)
2246 
    return self.recv_deleteTag()
2247 
 
2248 
  def send_deleteTag(self, displayName):
2249 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2250 
    args = deleteTag_args()
2251 
    args.displayName = displayName
2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
2256 
  def recv_deleteTag(self, ):
2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
2263 
    result = deleteTag_result()
2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
2266 
    if result.success is not None:
2267 
      return result.success
2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2269 
 
2270 
  def getAllTags(self, ):
2271 
    self.send_getAllTags()
2272 
    return self.recv_getAllTags()
2273 
 
2274 
  def send_getAllTags(self, ):
2275 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2276 
    args = getAllTags_args()
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_getAllTags(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = getAllTags_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
2291 
    if result.success is not None:
2292 
      return result.success
2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2294 
 
2295 
  def getAllEntitiesByTagName(self, displayName):
2296 
    """
2297 
    Parameters:
2298 
     - displayName
2299 
    """
2300 
    self.send_getAllEntitiesByTagName(displayName)
2301 
    return self.recv_getAllEntitiesByTagName()
2302 
 
2303 
  def send_getAllEntitiesByTagName(self, displayName):
2304 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2305 
    args = getAllEntitiesByTagName_args()
2306 
    args.displayName = displayName
2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_getAllEntitiesByTagName(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = getAllEntitiesByTagName_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
2321 
    if result.success is not None:
2322 
      return result.success
2323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2324 
 
6845 amit.gupta 2325 
  def getAllEntityTags(self, ):
2326 
    self.send_getAllEntityTags()
2327 
    return self.recv_getAllEntityTags()
2328 
 
2329 
  def send_getAllEntityTags(self, ):
2330 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2331 
    args = getAllEntityTags_args()
2332 
    args.write(self._oprot)
2333 
    self._oprot.writeMessageEnd()
2334 
    self._oprot.trans.flush()
2335 
 
2336 
  def recv_getAllEntityTags(self, ):
2337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2338 
    if mtype == TMessageType.EXCEPTION:
2339 
      x = TApplicationException()
2340 
      x.read(self._iprot)
2341 
      self._iprot.readMessageEnd()
2342 
      raise x
2343 
    result = getAllEntityTags_result()
2344 
    result.read(self._iprot)
2345 
    self._iprot.readMessageEnd()
2346 
    if result.success is not None:
2347 
      return result.success
2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2349 
 
8590 kshitij.so 2350 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2351 
    """
8579 kshitij.so 2352 
    Banner Related
2353 
 
6850 kshitij.so 2354 
    Parameters:
8590 kshitij.so 2355 
     - bannerCongregate
6850 kshitij.so 2356 
    """
8590 kshitij.so 2357 
    self.send_addBanner(bannerCongregate)
2358 
    self.recv_addBanner()
6850 kshitij.so 2359 
 
8590 kshitij.so 2360 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2361 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2362 
    args = addBanner_args()
8590 kshitij.so 2363 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_addBanner(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = addBanner_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
8590 kshitij.so 2378 
    return
6850 kshitij.so 2379 
 
8579 kshitij.so 2380 
  def updateBanner(self, banner):
2381 
    """
2382 
    Parameters:
2383 
     - banner
2384 
    """
2385 
    self.send_updateBanner(banner)
2386 
    return self.recv_updateBanner()
2387 
 
2388 
  def send_updateBanner(self, banner):
2389 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2390 
    args = updateBanner_args()
2391 
    args.banner = banner
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_updateBanner(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = updateBanner_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
2406 
    if result.success is not None:
2407 
      return result.success
2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2409 
 
6850 kshitij.so 2410 
  def getAllBanners(self, ):
2411 
    self.send_getAllBanners()
2412 
    return self.recv_getAllBanners()
2413 
 
2414 
  def send_getAllBanners(self, ):
2415 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2416 
    args = getAllBanners_args()
2417 
    args.write(self._oprot)
2418 
    self._oprot.writeMessageEnd()
2419 
    self._oprot.trans.flush()
2420 
 
2421 
  def recv_getAllBanners(self, ):
2422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2423 
    if mtype == TMessageType.EXCEPTION:
2424 
      x = TApplicationException()
2425 
      x.read(self._iprot)
2426 
      self._iprot.readMessageEnd()
2427 
      raise x
2428 
    result = getAllBanners_result()
2429 
    result.read(self._iprot)
2430 
    self._iprot.readMessageEnd()
2431 
    if result.success is not None:
2432 
      return result.success
2433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2434 
 
9155 kshitij.so 2435 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2436 
    """
2437 
    Parameters:
2438 
     - bannerName
9155 kshitij.so 2439 
     - bannerType
6850 kshitij.so 2440 
    """
9155 kshitij.so 2441 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2442 
    return self.recv_deleteBanner()
2443 
 
9155 kshitij.so 2444 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2445 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2446 
    args = deleteBanner_args()
2447 
    args.bannerName = bannerName
9155 kshitij.so 2448 
    args.bannerType = bannerType
6850 kshitij.so 2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_deleteBanner(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = deleteBanner_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
2463 
    if result.success is not None:
2464 
      return result.success
2465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2466 
 
9155 kshitij.so 2467 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2468 
    """
2469 
    Parameters:
2470 
     - bannerName
9155 kshitij.so 2471 
     - bannerType
6850 kshitij.so 2472 
    """
9155 kshitij.so 2473 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2474 
    return self.recv_getBannerDetails()
2475 
 
9155 kshitij.so 2476 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2477 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2478 
    args = getBannerDetails_args()
2479 
    args.bannerName = bannerName
9155 kshitij.so 2480 
    args.bannerType = bannerType
6850 kshitij.so 2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_getBannerDetails(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = getBannerDetails_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
2495 
    if result.success is not None:
2496 
      return result.success
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2498 
 
2499 
  def getActiveBanners(self, ):
2500 
    self.send_getActiveBanners()
2501 
    return self.recv_getActiveBanners()
2502 
 
2503 
  def send_getActiveBanners(self, ):
2504 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2505 
    args = getActiveBanners_args()
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_getActiveBanners(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = getActiveBanners_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
2520 
    if result.success is not None:
2521 
      return result.success
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2523 
 
8579 kshitij.so 2524 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2525 
    """
2526 
    Parameters:
8579 kshitij.so 2527 
     - bannerMaps
6849 kshitij.so 2528 
    """
8579 kshitij.so 2529 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2530 
    return self.recv_addBannerMap()
2531 
 
8579 kshitij.so 2532 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2533 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2534 
    args = addBannerMap_args()
8579 kshitij.so 2535 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2536 
    args.write(self._oprot)
2537 
    self._oprot.writeMessageEnd()
2538 
    self._oprot.trans.flush()
2539 
 
2540 
  def recv_addBannerMap(self, ):
2541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2542 
    if mtype == TMessageType.EXCEPTION:
2543 
      x = TApplicationException()
2544 
      x.read(self._iprot)
2545 
      self._iprot.readMessageEnd()
2546 
      raise x
2547 
    result = addBannerMap_result()
2548 
    result.read(self._iprot)
2549 
    self._iprot.readMessageEnd()
2550 
    if result.success is not None:
2551 
      return result.success
2552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2553 
 
8579 kshitij.so 2554 
  def updateBannerMap(self, bannerMap):
2555 
    """
2556 
    Parameters:
2557 
     - bannerMap
2558 
    """
2559 
    self.send_updateBannerMap(bannerMap)
2560 
    return self.recv_updateBannerMap()
2561 
 
2562 
  def send_updateBannerMap(self, bannerMap):
2563 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2564 
    args = updateBannerMap_args()
2565 
    args.bannerMap = bannerMap
2566 
    args.write(self._oprot)
2567 
    self._oprot.writeMessageEnd()
2568 
    self._oprot.trans.flush()
2569 
 
2570 
  def recv_updateBannerMap(self, ):
2571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2572 
    if mtype == TMessageType.EXCEPTION:
2573 
      x = TApplicationException()
2574 
      x.read(self._iprot)
2575 
      self._iprot.readMessageEnd()
2576 
      raise x
2577 
    result = updateBannerMap_result()
2578 
    result.read(self._iprot)
2579 
    self._iprot.readMessageEnd()
2580 
    if result.success is not None:
2581 
      return result.success
2582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2583 
 
6849 kshitij.so 2584 
  def deleteBannerMap(self, bannerName):
2585 
    """
2586 
    Parameters:
2587 
     - bannerName
2588 
    """
2589 
    self.send_deleteBannerMap(bannerName)
2590 
    return self.recv_deleteBannerMap()
2591 
 
2592 
  def send_deleteBannerMap(self, bannerName):
2593 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2594 
    args = deleteBannerMap_args()
2595 
    args.bannerName = bannerName
2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_deleteBannerMap(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = deleteBannerMap_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
2610 
    if result.success is not None:
2611 
      return result.success
2612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2613 
 
9155 kshitij.so 2614 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2615 
    """
2616 
    Parameters:
2617 
     - bannerName
9155 kshitij.so 2618 
     - bannerType
6849 kshitij.so 2619 
    """
9155 kshitij.so 2620 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2621 
    return self.recv_getBannerMapDetails()
2622 
 
9155 kshitij.so 2623 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2624 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2625 
    args = getBannerMapDetails_args()
2626 
    args.bannerName = bannerName
9155 kshitij.so 2627 
    args.bannerType = bannerType
6849 kshitij.so 2628 
    args.write(self._oprot)
2629 
    self._oprot.writeMessageEnd()
2630 
    self._oprot.trans.flush()
2631 
 
2632 
  def recv_getBannerMapDetails(self, ):
2633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2634 
    if mtype == TMessageType.EXCEPTION:
2635 
      x = TApplicationException()
2636 
      x.read(self._iprot)
2637 
      self._iprot.readMessageEnd()
2638 
      raise x
2639 
    result = getBannerMapDetails_result()
2640 
    result.read(self._iprot)
2641 
    self._iprot.readMessageEnd()
2642 
    if result.success is not None:
2643 
      return result.success
2644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2645 
 
8579 kshitij.so 2646 
  def addBannerUri(self, bannerUriMappings):
2647 
    """
2648 
    Parameters:
2649 
     - bannerUriMappings
2650 
    """
2651 
    self.send_addBannerUri(bannerUriMappings)
2652 
    self.recv_addBannerUri()
2653 
 
2654 
  def send_addBannerUri(self, bannerUriMappings):
2655 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2656 
    args = addBannerUri_args()
2657 
    args.bannerUriMappings = bannerUriMappings
2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2662 
  def recv_addBannerUri(self, ):
2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2669 
    result = addBannerUri_result()
2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
2672 
    return
2673 
 
9155 kshitij.so 2674 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2675 
    """
2676 
    Parameters:
2677 
     - bannerName
9155 kshitij.so 2678 
     - bannerType
8579 kshitij.so 2679 
    """
9155 kshitij.so 2680 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2681 
    return self.recv_getUriMapping()
2682 
 
9155 kshitij.so 2683 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2684 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2685 
    args = getUriMapping_args()
2686 
    args.bannerName = bannerName
9155 kshitij.so 2687 
    args.bannerType = bannerType
8579 kshitij.so 2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2692 
  def recv_getUriMapping(self, ):
2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2699 
    result = getUriMapping_result()
2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
2702 
    if result.success is not None:
2703 
      return result.success
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2705 
 
2706 
  def addCampaign(self, campaign):
2707 
    """
2708 
    Parameters:
2709 
     - campaign
2710 
    """
2711 
    self.send_addCampaign(campaign)
2712 
    self.recv_addCampaign()
2713 
 
2714 
  def send_addCampaign(self, campaign):
2715 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2716 
    args = addCampaign_args()
2717 
    args.campaign = campaign
2718 
    args.write(self._oprot)
2719 
    self._oprot.writeMessageEnd()
2720 
    self._oprot.trans.flush()
2721 
 
2722 
  def recv_addCampaign(self, ):
2723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2724 
    if mtype == TMessageType.EXCEPTION:
2725 
      x = TApplicationException()
2726 
      x.read(self._iprot)
2727 
      self._iprot.readMessageEnd()
2728 
      raise x
2729 
    result = addCampaign_result()
2730 
    result.read(self._iprot)
2731 
    self._iprot.readMessageEnd()
2732 
    return
2733 
 
2734 
  def getCampaigns(self, campaignName):
2735 
    """
2736 
    Parameters:
2737 
     - campaignName
2738 
    """
2739 
    self.send_getCampaigns(campaignName)
2740 
    return self.recv_getCampaigns()
2741 
 
2742 
  def send_getCampaigns(self, campaignName):
2743 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2744 
    args = getCampaigns_args()
2745 
    args.campaignName = campaignName
2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
2750 
  def recv_getCampaigns(self, ):
2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
2757 
    result = getCampaigns_result()
2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
2760 
    if result.success is not None:
2761 
      return result.success
2762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2763 
 
2764 
  def deleteCampaign(self, campaignId):
2765 
    """
2766 
    Parameters:
2767 
     - campaignId
2768 
    """
2769 
    self.send_deleteCampaign(campaignId)
2770 
    self.recv_deleteCampaign()
2771 
 
2772 
  def send_deleteCampaign(self, campaignId):
2773 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2774 
    args = deleteCampaign_args()
2775 
    args.campaignId = campaignId
2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
2780 
  def recv_deleteCampaign(self, ):
2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
2787 
    result = deleteCampaign_result()
2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
2790 
    return
2791 
 
2792 
  def getAllCampaigns(self, ):
2793 
    self.send_getAllCampaigns()
2794 
    return self.recv_getAllCampaigns()
2795 
 
2796 
  def send_getAllCampaigns(self, ):
2797 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2798 
    args = getAllCampaigns_args()
2799 
    args.write(self._oprot)
2800 
    self._oprot.writeMessageEnd()
2801 
    self._oprot.trans.flush()
2802 
 
2803 
  def recv_getAllCampaigns(self, ):
2804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2805 
    if mtype == TMessageType.EXCEPTION:
2806 
      x = TApplicationException()
2807 
      x.read(self._iprot)
2808 
      self._iprot.readMessageEnd()
2809 
      raise x
2810 
    result = getAllCampaigns_result()
2811 
    result.read(self._iprot)
2812 
    self._iprot.readMessageEnd()
2813 
    if result.success is not None:
2814 
      return result.success
2815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2816 
 
9155 kshitij.so 2817 
  def getActiveBannersForMobileSite(self, ):
2818 
    self.send_getActiveBannersForMobileSite()
2819 
    return self.recv_getActiveBannersForMobileSite()
2820 
 
2821 
  def send_getActiveBannersForMobileSite(self, ):
2822 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2823 
    args = getActiveBannersForMobileSite_args()
2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2828 
  def recv_getActiveBannersForMobileSite(self, ):
2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2835 
    result = getActiveBannersForMobileSite_result()
2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
2838 
    if result.success is not None:
2839 
      return result.success
2840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2841 
 
5944 mandeep.dh 2842 
  def deleteSimilarItem(self, itemId, catalogItemId):
2843 
    """
2844 
    Delete similar item.
2845 
 
2846 
    Parameters:
2847 
     - itemId
2848 
     - catalogItemId
2849 
    """
2850 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2851 
    return self.recv_deleteSimilarItem()
2852 
 
2853 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2854 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2855 
    args = deleteSimilarItem_args()
2856 
    args.itemId = itemId
2857 
    args.catalogItemId = catalogItemId
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_deleteSimilarItem(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = deleteSimilarItem_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
2872 
    if result.success is not None:
2873 
      return result.success
2874 
    if result.cex is not None:
2875 
      raise result.cex
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2877 
 
2878 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2879 
    """
2880 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2881 
    If yes, returns the itemId else returns 0
2882 
 
2883 
    Parameters:
2884 
     - brand
2885 
     - modelNumber
2886 
     - modelName
2887 
     - color
2888 
    """
2889 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2890 
    return self.recv_checkSimilarItem()
2891 
 
2892 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2893 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2894 
    args = checkSimilarItem_args()
2895 
    args.brand = brand
2896 
    args.modelNumber = modelNumber
2897 
    args.modelName = modelName
2898 
    args.color = color
2899 
    args.write(self._oprot)
2900 
    self._oprot.writeMessageEnd()
2901 
    self._oprot.trans.flush()
2902 
 
2903 
  def recv_checkSimilarItem(self, ):
2904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2905 
    if mtype == TMessageType.EXCEPTION:
2906 
      x = TApplicationException()
2907 
      x.read(self._iprot)
2908 
      self._iprot.readMessageEnd()
2909 
      raise x
2910 
    result = checkSimilarItem_result()
2911 
    result.read(self._iprot)
2912 
    self._iprot.readMessageEnd()
2913 
    if result.success is not None:
2914 
      return result.success
2915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2916 
 
2917 
  def validateRiskyStatus(self, itemId):
2918 
    """
2919 
    Check wether item is risky and change status if inventory is not available for risky items
2920 
 
2921 
    Parameters:
2922 
     - itemId
2923 
    """
2924 
    self.send_validateRiskyStatus(itemId)
2925 
    self.recv_validateRiskyStatus()
2926 
 
2927 
  def send_validateRiskyStatus(self, itemId):
2928 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2929 
    args = validateRiskyStatus_args()
2930 
    args.itemId = itemId
2931 
    args.write(self._oprot)
2932 
    self._oprot.writeMessageEnd()
2933 
    self._oprot.trans.flush()
2934 
 
2935 
  def recv_validateRiskyStatus(self, ):
2936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2937 
    if mtype == TMessageType.EXCEPTION:
2938 
      x = TApplicationException()
2939 
      x.read(self._iprot)
2940 
      self._iprot.readMessageEnd()
2941 
      raise x
2942 
    result = validateRiskyStatus_result()
2943 
    result.read(self._iprot)
2944 
    self._iprot.readMessageEnd()
2945 
    return
2946 
 
2947 
  def changeItemRiskyFlag(self, itemId, risky):
2948 
    """
2949 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2950 
 
2951 
    Parameters:
2952 
     - itemId
2953 
     - risky
2954 
    """
2955 
    self.send_changeItemRiskyFlag(itemId, risky)
2956 
    self.recv_changeItemRiskyFlag()
2957 
 
2958 
  def send_changeItemRiskyFlag(self, itemId, risky):
2959 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2960 
    args = changeItemRiskyFlag_args()
2961 
    args.itemId = itemId
2962 
    args.risky = risky
2963 
    args.write(self._oprot)
2964 
    self._oprot.writeMessageEnd()
2965 
    self._oprot.trans.flush()
2966 
 
2967 
  def recv_changeItemRiskyFlag(self, ):
2968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2969 
    if mtype == TMessageType.EXCEPTION:
2970 
      x = TApplicationException()
2971 
      x.read(self._iprot)
2972 
      self._iprot.readMessageEnd()
2973 
      raise x
2974 
    result = changeItemRiskyFlag_result()
2975 
    result.read(self._iprot)
2976 
    self._iprot.readMessageEnd()
2977 
    return
2978 
 
2979 
  def getItemsByRiskyFlag(self, ):
2980 
    """
2981 
    Returns list of items marked as risky.
2982 
    """
2983 
    self.send_getItemsByRiskyFlag()
2984 
    return self.recv_getItemsByRiskyFlag()
2985 
 
2986 
  def send_getItemsByRiskyFlag(self, ):
2987 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2988 
    args = getItemsByRiskyFlag_args()
2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_getItemsByRiskyFlag(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = getItemsByRiskyFlag_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3006 
 
3007 
  def getItemsForMasterSheet(self, category, brand):
3008 
    """
3009 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3010 
 
3011 
    Parameters:
3012 
     - category
3013 
     - brand
3014 
    """
3015 
    self.send_getItemsForMasterSheet(category, brand)
3016 
    return self.recv_getItemsForMasterSheet()
3017 
 
3018 
  def send_getItemsForMasterSheet(self, category, brand):
3019 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3020 
    args = getItemsForMasterSheet_args()
3021 
    args.category = category
3022 
    args.brand = brand
3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3027 
  def recv_getItemsForMasterSheet(self, ):
3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3034 
    result = getItemsForMasterSheet_result()
3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    if result.success is not None:
3038 
      return result.success
3039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3040 
 
3041 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3042 
    """
3043 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3044 
 
3045 
    Parameters:
3046 
     - beginIndex
3047 
     - totalItems
3048 
     - itemId
3049 
    """
3050 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3051 
    return self.recv_getSimilarItemsCatalogIds()
3052 
 
3053 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3054 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3055 
    args = getSimilarItemsCatalogIds_args()
3056 
    args.beginIndex = beginIndex
3057 
    args.totalItems = totalItems
3058 
    args.itemId = itemId
3059 
    args.write(self._oprot)
3060 
    self._oprot.writeMessageEnd()
3061 
    self._oprot.trans.flush()
3062 
 
3063 
  def recv_getSimilarItemsCatalogIds(self, ):
3064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3065 
    if mtype == TMessageType.EXCEPTION:
3066 
      x = TApplicationException()
3067 
      x.read(self._iprot)
3068 
      self._iprot.readMessageEnd()
3069 
      raise x
3070 
    result = getSimilarItemsCatalogIds_result()
3071 
    result.read(self._iprot)
3072 
    self._iprot.readMessageEnd()
3073 
    if result.success is not None:
3074 
      return result.success
3075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3076 
 
3077 
  def addProductNotification(self, itemId, email):
3078 
    """
3079 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3080 
 
3081 
    Parameters:
3082 
     - itemId
3083 
     - email
3084 
    """
3085 
    self.send_addProductNotification(itemId, email)
3086 
    return self.recv_addProductNotification()
3087 
 
3088 
  def send_addProductNotification(self, itemId, email):
3089 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3090 
    args = addProductNotification_args()
3091 
    args.itemId = itemId
3092 
    args.email = email
3093 
    args.write(self._oprot)
3094 
    self._oprot.writeMessageEnd()
3095 
    self._oprot.trans.flush()
3096 
 
3097 
  def recv_addProductNotification(self, ):
3098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3099 
    if mtype == TMessageType.EXCEPTION:
3100 
      x = TApplicationException()
3101 
      x.read(self._iprot)
3102 
      self._iprot.readMessageEnd()
3103 
      raise x
3104 
    result = addProductNotification_result()
3105 
    result.read(self._iprot)
3106 
    self._iprot.readMessageEnd()
3107 
    if result.success is not None:
3108 
      return result.success
3109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3110 
 
3111 
  def sendProductNotifications(self, ):
3112 
    """
3113 
    Send the product notifications to the users for items which has stock.
3114 
    """
3115 
    self.send_sendProductNotifications()
3116 
    return self.recv_sendProductNotifications()
3117 
 
3118 
  def send_sendProductNotifications(self, ):
3119 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3120 
    args = sendProductNotifications_args()
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_sendProductNotifications(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = sendProductNotifications_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.success is not None:
3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3138 
 
3139 
  def getAllBrandsByCategory(self, categoryId):
3140 
    """
3141 
    Returns list of brand names for a given category Id
3142 
 
3143 
    Parameters:
3144 
     - categoryId
3145 
    """
3146 
    self.send_getAllBrandsByCategory(categoryId)
3147 
    return self.recv_getAllBrandsByCategory()
3148 
 
3149 
  def send_getAllBrandsByCategory(self, categoryId):
3150 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3151 
    args = getAllBrandsByCategory_args()
3152 
    args.categoryId = categoryId
3153 
    args.write(self._oprot)
3154 
    self._oprot.writeMessageEnd()
3155 
    self._oprot.trans.flush()
3156 
 
3157 
  def recv_getAllBrandsByCategory(self, ):
3158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3159 
    if mtype == TMessageType.EXCEPTION:
3160 
      x = TApplicationException()
3161 
      x.read(self._iprot)
3162 
      self._iprot.readMessageEnd()
3163 
      raise x
3164 
    result = getAllBrandsByCategory_result()
3165 
    result.read(self._iprot)
3166 
    self._iprot.readMessageEnd()
3167 
    if result.success is not None:
3168 
      return result.success
3169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3170 
 
3171 
  def getAllBrands(self, ):
3172 
    """
3173 
    Returns list of brand names
3174 
    """
3175 
    self.send_getAllBrands()
3176 
    return self.recv_getAllBrands()
3177 
 
3178 
  def send_getAllBrands(self, ):
3179 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3180 
    args = getAllBrands_args()
3181 
    args.write(self._oprot)
3182 
    self._oprot.writeMessageEnd()
3183 
    self._oprot.trans.flush()
3184 
 
3185 
  def recv_getAllBrands(self, ):
3186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3187 
    if mtype == TMessageType.EXCEPTION:
3188 
      x = TApplicationException()
3189 
      x.read(self._iprot)
3190 
      self._iprot.readMessageEnd()
3191 
      raise x
3192 
    result = getAllBrands_result()
3193 
    result.read(self._iprot)
3194 
    self._iprot.readMessageEnd()
3195 
    if result.success is not None:
3196 
      return result.success
3197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3198 
 
3199 
  def getAllSources(self, ):
3200 
    """
3201 
    Return list of all sources
3202 
    """
3203 
    self.send_getAllSources()
3204 
    return self.recv_getAllSources()
3205 
 
3206 
  def send_getAllSources(self, ):
3207 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3208 
    args = getAllSources_args()
3209 
    args.write(self._oprot)
3210 
    self._oprot.writeMessageEnd()
3211 
    self._oprot.trans.flush()
3212 
 
3213 
  def recv_getAllSources(self, ):
3214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3215 
    if mtype == TMessageType.EXCEPTION:
3216 
      x = TApplicationException()
3217 
      x.read(self._iprot)
3218 
      self._iprot.readMessageEnd()
3219 
      raise x
3220 
    result = getAllSources_result()
3221 
    result.read(self._iprot)
3222 
    self._iprot.readMessageEnd()
3223 
    if result.success is not None:
3224 
      return result.success
3225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3226 
 
3227 
  def getItemPricingBySource(self, itemId, sourceId):
3228 
    """
3229 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3230 
 
3231 
    Parameters:
3232 
     - itemId
3233 
     - sourceId
3234 
    """
3235 
    self.send_getItemPricingBySource(itemId, sourceId)
3236 
    return self.recv_getItemPricingBySource()
3237 
 
3238 
  def send_getItemPricingBySource(self, itemId, sourceId):
3239 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3240 
    args = getItemPricingBySource_args()
3241 
    args.itemId = itemId
3242 
    args.sourceId = sourceId
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_getItemPricingBySource(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = getItemPricingBySource_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
3257 
    if result.success is not None:
3258 
      return result.success
3259 
    if result.cex is not None:
3260 
      raise result.cex
3261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3262 
 
3263 
  def addSourceItemPricing(self, sourceItemPricing):
3264 
    """
3265 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3266 
    If item is not found or source is not found, it will throw exception.
3267 
 
3268 
    Parameters:
3269 
     - sourceItemPricing
3270 
    """
3271 
    self.send_addSourceItemPricing(sourceItemPricing)
3272 
    self.recv_addSourceItemPricing()
3273 
 
3274 
  def send_addSourceItemPricing(self, sourceItemPricing):
3275 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3276 
    args = addSourceItemPricing_args()
3277 
    args.sourceItemPricing = sourceItemPricing
3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_addSourceItemPricing(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = addSourceItemPricing_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.cex is not None:
3293 
      raise result.cex
3294 
    return
3295 
 
3296 
  def getAllSourcePricing(self, itemId):
3297 
    """
3298 
    Returns the list of source pricing information of an item.
3299 
    Raises an exception if item not found corresponding to itemId
3300 
 
3301 
    Parameters:
3302 
     - itemId
3303 
    """
3304 
    self.send_getAllSourcePricing(itemId)
3305 
    return self.recv_getAllSourcePricing()
3306 
 
3307 
  def send_getAllSourcePricing(self, itemId):
3308 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3309 
    args = getAllSourcePricing_args()
3310 
    args.itemId = itemId
3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3315 
  def recv_getAllSourcePricing(self, ):
3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3322 
    result = getAllSourcePricing_result()
3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3325 
    if result.success is not None:
3326 
      return result.success
3327 
    if result.cex is not None:
3328 
      raise result.cex
3329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3330 
 
3331 
  def getItemForSource(self, item_id, sourceId):
3332 
    """
3333 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3334 
 
3335 
    Parameters:
3336 
     - item_id
3337 
     - sourceId
3338 
    """
3339 
    self.send_getItemForSource(item_id, sourceId)
3340 
    return self.recv_getItemForSource()
3341 
 
3342 
  def send_getItemForSource(self, item_id, sourceId):
3343 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3344 
    args = getItemForSource_args()
3345 
    args.item_id = item_id
3346 
    args.sourceId = sourceId
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_getItemForSource(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = getItemForSource_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3361 
    if result.success is not None:
3362 
      return result.success
3363 
    if result.cex is not None:
3364 
      raise result.cex
3365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3366 
 
3367 
  def searchItemsInRange(self, searchTerms, offset, limit):
3368 
    """
3369 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3370 
 
3371 
    Parameters:
3372 
     - searchTerms
3373 
     - offset
3374 
     - limit
3375 
    """
3376 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3377 
    return self.recv_searchItemsInRange()
3378 
 
3379 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3380 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3381 
    args = searchItemsInRange_args()
3382 
    args.searchTerms = searchTerms
3383 
    args.offset = offset
3384 
    args.limit = limit
3385 
    args.write(self._oprot)
3386 
    self._oprot.writeMessageEnd()
3387 
    self._oprot.trans.flush()
3388 
 
3389 
  def recv_searchItemsInRange(self, ):
3390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3391 
    if mtype == TMessageType.EXCEPTION:
3392 
      x = TApplicationException()
3393 
      x.read(self._iprot)
3394 
      self._iprot.readMessageEnd()
3395 
      raise x
3396 
    result = searchItemsInRange_result()
3397 
    result.read(self._iprot)
3398 
    self._iprot.readMessageEnd()
3399 
    if result.success is not None:
3400 
      return result.success
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3402 
 
3403 
  def getSearchResultCount(self, searchTerms):
3404 
    """
3405 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3406 
 
3407 
    Parameters:
3408 
     - searchTerms
3409 
    """
3410 
    self.send_getSearchResultCount(searchTerms)
3411 
    return self.recv_getSearchResultCount()
3412 
 
3413 
  def send_getSearchResultCount(self, searchTerms):
3414 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3415 
    args = getSearchResultCount_args()
3416 
    args.searchTerms = searchTerms
3417 
    args.write(self._oprot)
3418 
    self._oprot.writeMessageEnd()
3419 
    self._oprot.trans.flush()
3420 
 
3421 
  def recv_getSearchResultCount(self, ):
3422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3423 
    if mtype == TMessageType.EXCEPTION:
3424 
      x = TApplicationException()
3425 
      x.read(self._iprot)
3426 
      self._iprot.readMessageEnd()
3427 
      raise x
3428 
    result = getSearchResultCount_result()
3429 
    result.read(self._iprot)
3430 
    self._iprot.readMessageEnd()
3431 
    if result.success is not None:
3432 
      return result.success
3433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3434 
 
3435 
  def getProductNotifications(self, startDateTime):
3436 
    """
3437 
    Returns a list of product notifications added after a supplied datetime
3438 
 
3439 
    Parameters:
3440 
     - startDateTime
3441 
    """
3442 
    self.send_getProductNotifications(startDateTime)
3443 
    return self.recv_getProductNotifications()
3444 
 
3445 
  def send_getProductNotifications(self, startDateTime):
3446 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3447 
    args = getProductNotifications_args()
3448 
    args.startDateTime = startDateTime
3449 
    args.write(self._oprot)
3450 
    self._oprot.writeMessageEnd()
3451 
    self._oprot.trans.flush()
3452 
 
3453 
  def recv_getProductNotifications(self, ):
3454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3455 
    if mtype == TMessageType.EXCEPTION:
3456 
      x = TApplicationException()
3457 
      x.read(self._iprot)
3458 
      self._iprot.readMessageEnd()
3459 
      raise x
3460 
    result = getProductNotifications_result()
3461 
    result.read(self._iprot)
3462 
    self._iprot.readMessageEnd()
3463 
    if result.success is not None:
3464 
      return result.success
3465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3466 
 
7897 amar.kumar 3467 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3468 
    """
3469 
    Returns a list of count of requests for product notification against each item
3470 
 
3471 
    Parameters:
3472 
     - startDateTime
7897 amar.kumar 3473 
     - categoryId
5944 mandeep.dh 3474 
    """
7897 amar.kumar 3475 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3476 
    return self.recv_getProductNotificationRequestCount()
3477 
 
7897 amar.kumar 3478 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3479 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3480 
    args = getProductNotificationRequestCount_args()
3481 
    args.startDateTime = startDateTime
7897 amar.kumar 3482 
    args.categoryId = categoryId
5944 mandeep.dh 3483 
    args.write(self._oprot)
3484 
    self._oprot.writeMessageEnd()
3485 
    self._oprot.trans.flush()
3486 
 
3487 
  def recv_getProductNotificationRequestCount(self, ):
3488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3489 
    if mtype == TMessageType.EXCEPTION:
3490 
      x = TApplicationException()
3491 
      x.read(self._iprot)
3492 
      self._iprot.readMessageEnd()
3493 
      raise x
3494 
    result = getProductNotificationRequestCount_result()
3495 
    result.read(self._iprot)
3496 
    self._iprot.readMessageEnd()
3497 
    if result.success is not None:
3498 
      return result.success
3499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3500 
 
3501 
  def addAuthorizationLog(self, itemId, username, reason):
3502 
    """
3503 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3504 
 
3505 
    Parameters:
3506 
     - itemId
3507 
     - username
3508 
     - reason
3509 
    """
3510 
    self.send_addAuthorizationLog(itemId, username, reason)
3511 
    return self.recv_addAuthorizationLog()
3512 
 
3513 
  def send_addAuthorizationLog(self, itemId, username, reason):
3514 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3515 
    args = addAuthorizationLog_args()
3516 
    args.itemId = itemId
3517 
    args.username = username
3518 
    args.reason = reason
3519 
    args.write(self._oprot)
3520 
    self._oprot.writeMessageEnd()
3521 
    self._oprot.trans.flush()
3522 
 
3523 
  def recv_addAuthorizationLog(self, ):
3524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3525 
    if mtype == TMessageType.EXCEPTION:
3526 
      x = TApplicationException()
3527 
      x.read(self._iprot)
3528 
      self._iprot.readMessageEnd()
3529 
      raise x
3530 
    result = addAuthorizationLog_result()
3531 
    result.read(self._iprot)
3532 
    self._iprot.readMessageEnd()
3533 
    if result.success is not None:
3534 
      return result.success
3535 
    if result.cex is not None:
3536 
      raise result.cex
3537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3538 
 
3539 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3540 
    """
3541 
    Parameters:
3542 
     - catalog_item_id
3543 
     - voucherType
3544 
     - voucherAmount
3545 
    """
3546 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3547 
    return self.recv_addupdateVoucherForItem()
3548 
 
3549 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3550 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3551 
    args = addupdateVoucherForItem_args()
3552 
    args.catalog_item_id = catalog_item_id
3553 
    args.voucherType = voucherType
3554 
    args.voucherAmount = voucherAmount
3555 
    args.write(self._oprot)
3556 
    self._oprot.writeMessageEnd()
3557 
    self._oprot.trans.flush()
3558 
 
3559 
  def recv_addupdateVoucherForItem(self, ):
3560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3561 
    if mtype == TMessageType.EXCEPTION:
3562 
      x = TApplicationException()
3563 
      x.read(self._iprot)
3564 
      self._iprot.readMessageEnd()
3565 
      raise x
3566 
    result = addupdateVoucherForItem_result()
3567 
    result.read(self._iprot)
3568 
    self._iprot.readMessageEnd()
3569 
    if result.success is not None:
3570 
      return result.success
3571 
    if result.cex is not None:
3572 
      raise result.cex
3573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3574 
 
3575 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3576 
    """
3577 
    Parameters:
3578 
     - catalog_item_id
3579 
     - voucherType
3580 
    """
3581 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3582 
    return self.recv_deleteVoucherForItem()
3583 
 
3584 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3585 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3586 
    args = deleteVoucherForItem_args()
3587 
    args.catalog_item_id = catalog_item_id
3588 
    args.voucherType = voucherType
3589 
    args.write(self._oprot)
3590 
    self._oprot.writeMessageEnd()
3591 
    self._oprot.trans.flush()
3592 
 
3593 
  def recv_deleteVoucherForItem(self, ):
3594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3595 
    if mtype == TMessageType.EXCEPTION:
3596 
      x = TApplicationException()
3597 
      x.read(self._iprot)
3598 
      self._iprot.readMessageEnd()
3599 
      raise x
3600 
    result = deleteVoucherForItem_result()
3601 
    result.read(self._iprot)
3602 
    self._iprot.readMessageEnd()
3603 
    if result.success is not None:
3604 
      return result.success
3605 
    if result.cex is not None:
3606 
      raise result.cex
3607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3608 
 
3609 
  def getVoucherAmount(self, itemId, voucherType):
3610 
    """
3611 
    Parameters:
3612 
     - itemId
3613 
     - voucherType
3614 
    """
3615 
    self.send_getVoucherAmount(itemId, voucherType)
3616 
    return self.recv_getVoucherAmount()
3617 
 
3618 
  def send_getVoucherAmount(self, itemId, voucherType):
3619 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3620 
    args = getVoucherAmount_args()
3621 
    args.itemId = itemId
3622 
    args.voucherType = voucherType
3623 
    args.write(self._oprot)
3624 
    self._oprot.writeMessageEnd()
3625 
    self._oprot.trans.flush()
3626 
 
3627 
  def recv_getVoucherAmount(self, ):
3628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3629 
    if mtype == TMessageType.EXCEPTION:
3630 
      x = TApplicationException()
3631 
      x.read(self._iprot)
3632 
      self._iprot.readMessageEnd()
3633 
      raise x
3634 
    result = getVoucherAmount_result()
3635 
    result.read(self._iprot)
3636 
    self._iprot.readMessageEnd()
3637 
    if result.success is not None:
3638 
      return result.success
3639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3640 
 
3641 
  def getAllItemVouchers(self, itemId):
3642 
    """
3643 
    Parameters:
3644 
     - itemId
3645 
    """
3646 
    self.send_getAllItemVouchers(itemId)
3647 
    return self.recv_getAllItemVouchers()
3648 
 
3649 
  def send_getAllItemVouchers(self, itemId):
3650 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3651 
    args = getAllItemVouchers_args()
3652 
    args.itemId = itemId
3653 
    args.write(self._oprot)
3654 
    self._oprot.writeMessageEnd()
3655 
    self._oprot.trans.flush()
3656 
 
3657 
  def recv_getAllItemVouchers(self, ):
3658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3659 
    if mtype == TMessageType.EXCEPTION:
3660 
      x = TApplicationException()
3661 
      x.read(self._iprot)
3662 
      self._iprot.readMessageEnd()
3663 
      raise x
3664 
    result = getAllItemVouchers_result()
3665 
    result.read(self._iprot)
3666 
    self._iprot.readMessageEnd()
3667 
    if result.success is not None:
3668 
      return result.success
3669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3670 
 
3671 
  def isValidCatalogItemId(self, catalog_item_id):
3672 
    """
3673 
    Parameters:
3674 
     - catalog_item_id
3675 
    """
3676 
    self.send_isValidCatalogItemId(catalog_item_id)
3677 
    return self.recv_isValidCatalogItemId()
3678 
 
3679 
  def send_isValidCatalogItemId(self, catalog_item_id):
3680 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3681 
    args = isValidCatalogItemId_args()
3682 
    args.catalog_item_id = catalog_item_id
3683 
    args.write(self._oprot)
3684 
    self._oprot.writeMessageEnd()
3685 
    self._oprot.trans.flush()
3686 
 
3687 
  def recv_isValidCatalogItemId(self, ):
3688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3689 
    if mtype == TMessageType.EXCEPTION:
3690 
      x = TApplicationException()
3691 
      x.read(self._iprot)
3692 
      self._iprot.readMessageEnd()
3693 
      raise x
3694 
    result = isValidCatalogItemId_result()
3695 
    result.read(self._iprot)
3696 
    self._iprot.readMessageEnd()
3697 
    if result.success is not None:
3698 
      return result.success
3699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3700 
 
7330 amit.gupta 3701 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3702 
    """
3703 
    Parameters:
3704 
     - itemId
7330 amit.gupta 3705 
     - stateId
6039 amit.gupta 3706 
     - price
3707 
    """
7330 amit.gupta 3708 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3709 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3710 
 
7330 amit.gupta 3711 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3712 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3713 
    args = getVatPercentageForItem_args()
3714 
    args.itemId = itemId
7330 amit.gupta 3715 
    args.stateId = stateId
6039 amit.gupta 3716 
    args.price = price
3717 
    args.write(self._oprot)
3718 
    self._oprot.writeMessageEnd()
3719 
    self._oprot.trans.flush()
3720 
 
3721 
  def recv_getVatPercentageForItem(self, ):
3722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3723 
    if mtype == TMessageType.EXCEPTION:
3724 
      x = TApplicationException()
3725 
      x.read(self._iprot)
3726 
      self._iprot.readMessageEnd()
3727 
      raise x
3728 
    result = getVatPercentageForItem_result()
3729 
    result.read(self._iprot)
3730 
    self._iprot.readMessageEnd()
3731 
    if result.success is not None:
3732 
      return result.success
7340 amit.gupta 3733 
    if result.cex is not None:
3734 
      raise result.cex
6039 amit.gupta 3735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3736 
 
3737 
  def getVatAmountForItem(self, itemId, price):
3738 
    """
3739 
    Parameters:
3740 
     - itemId
3741 
     - price
3742 
    """
3743 
    self.send_getVatAmountForItem(itemId, price)
3744 
    return self.recv_getVatAmountForItem()
3745 
 
3746 
  def send_getVatAmountForItem(self, itemId, price):
3747 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3748 
    args = getVatAmountForItem_args()
3749 
    args.itemId = itemId
3750 
    args.price = price
3751 
    args.write(self._oprot)
3752 
    self._oprot.writeMessageEnd()
3753 
    self._oprot.trans.flush()
3754 
 
3755 
  def recv_getVatAmountForItem(self, ):
3756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3757 
    if mtype == TMessageType.EXCEPTION:
3758 
      x = TApplicationException()
3759 
      x.read(self._iprot)
3760 
      self._iprot.readMessageEnd()
3761 
      raise x
3762 
    result = getVatAmountForItem_result()
3763 
    result.read(self._iprot)
3764 
    self._iprot.readMessageEnd()
3765 
    if result.success is not None:
3766 
      return result.success
3767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3768 
 
6531 vikram.rag 3769 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3770 
    """
3771 
    Parameters:
3772 
     - offset
3773 
     - limit
3774 
    """
3775 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3776 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3777 
 
6531 vikram.rag 3778 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3779 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3780 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3781 
    args.offset = offset
3782 
    args.limit = limit
3783 
    args.write(self._oprot)
3784 
    self._oprot.writeMessageEnd()
3785 
    self._oprot.trans.flush()
3786 
 
3787 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3789 
    if mtype == TMessageType.EXCEPTION:
3790 
      x = TApplicationException()
3791 
      x.read(self._iprot)
3792 
      self._iprot.readMessageEnd()
3793 
      raise x
3794 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3795 
    result.read(self._iprot)
3796 
    self._iprot.readMessageEnd()
3797 
    if result.success is not None:
3798 
      return result.success
3799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3800 
 
6821 amar.kumar 3801 
  def getAllAliveItems(self, ):
3802 
    self.send_getAllAliveItems()
3803 
    return self.recv_getAllAliveItems()
3804 
 
3805 
  def send_getAllAliveItems(self, ):
3806 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3807 
    args = getAllAliveItems_args()
3808 
    args.write(self._oprot)
3809 
    self._oprot.writeMessageEnd()
3810 
    self._oprot.trans.flush()
3811 
 
3812 
  def recv_getAllAliveItems(self, ):
3813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3814 
    if mtype == TMessageType.EXCEPTION:
3815 
      x = TApplicationException()
3816 
      x.read(self._iprot)
3817 
      self._iprot.readMessageEnd()
3818 
      raise x
3819 
    result = getAllAliveItems_result()
3820 
    result.read(self._iprot)
3821 
    self._iprot.readMessageEnd()
3822 
    if result.success is not None:
3823 
      return result.success
3824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3825 
 
6921 anupam.sin 3826 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3827 
    """
3828 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3829 
 
6805 anupam.sin 3830 
    Parameters:
3831 
     - itemId
6921 anupam.sin 3832 
     - price
6805 anupam.sin 3833 
     - insurerId
3834 
     - quantity
3835 
    """
6921 anupam.sin 3836 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3837 
    return self.recv_getInsuranceAmount()
3838 
 
6921 anupam.sin 3839 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3840 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3841 
    args = getInsuranceAmount_args()
3842 
    args.itemId = itemId
6921 anupam.sin 3843 
    args.price = price
6805 anupam.sin 3844 
    args.insurerId = insurerId
3845 
    args.quantity = quantity
3846 
    args.write(self._oprot)
3847 
    self._oprot.writeMessageEnd()
3848 
    self._oprot.trans.flush()
3849 
 
3850 
  def recv_getInsuranceAmount(self, ):
3851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3852 
    if mtype == TMessageType.EXCEPTION:
3853 
      x = TApplicationException()
3854 
      x.read(self._iprot)
3855 
      self._iprot.readMessageEnd()
3856 
      raise x
3857 
    result = getInsuranceAmount_result()
3858 
    result.read(self._iprot)
3859 
    self._iprot.readMessageEnd()
3860 
    if result.success is not None:
3861 
      return result.success
3862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3863 
 
3864 
  def getInsurer(self, insurerId):
3865 
    """
3866 
    Parameters:
3867 
     - insurerId
3868 
    """
3869 
    self.send_getInsurer(insurerId)
3870 
    return self.recv_getInsurer()
3871 
 
3872 
  def send_getInsurer(self, insurerId):
3873 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3874 
    args = getInsurer_args()
3875 
    args.insurerId = insurerId
3876 
    args.write(self._oprot)
3877 
    self._oprot.writeMessageEnd()
3878 
    self._oprot.trans.flush()
3879 
 
3880 
  def recv_getInsurer(self, ):
3881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3882 
    if mtype == TMessageType.EXCEPTION:
3883 
      x = TApplicationException()
3884 
      x.read(self._iprot)
3885 
      self._iprot.readMessageEnd()
3886 
      raise x
3887 
    result = getInsurer_result()
3888 
    result.read(self._iprot)
3889 
    self._iprot.readMessageEnd()
3890 
    if result.success is not None:
3891 
      return result.success
3892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3893 
 
6838 vikram.rag 3894 
  def getAllInsurers(self, ):
3895 
    self.send_getAllInsurers()
3896 
    return self.recv_getAllInsurers()
6805 anupam.sin 3897 
 
6838 vikram.rag 3898 
  def send_getAllInsurers(self, ):
3899 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3900 
    args = getAllInsurers_args()
3901 
    args.write(self._oprot)
3902 
    self._oprot.writeMessageEnd()
3903 
    self._oprot.trans.flush()
3904 
 
3905 
  def recv_getAllInsurers(self, ):
3906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3907 
    if mtype == TMessageType.EXCEPTION:
3908 
      x = TApplicationException()
3909 
      x.read(self._iprot)
3910 
      self._iprot.readMessageEnd()
3911 
      raise x
3912 
    result = getAllInsurers_result()
3913 
    result.read(self._iprot)
3914 
    self._iprot.readMessageEnd()
3915 
    if result.success is not None:
3916 
      return result.success
3917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3918 
 
6962 rajveer 3919 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3920 
    """
3921 
    Parameters:
3922 
     - insurerId
3923 
     - amount
3924 
    """
3925 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3926 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3927 
 
6962 rajveer 3928 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3929 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3930 
    args = updateInsuranceDeclaredAmount_args()
3931 
    args.insurerId = insurerId
3932 
    args.amount = amount
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_updateInsuranceDeclaredAmount(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = updateInsuranceDeclaredAmount_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    return
3948 
 
7190 amar.kumar 3949 
  def getFreebieForItem(self, itemId):
3950 
    """
3951 
    Parameters:
3952 
     - itemId
3953 
    """
3954 
    self.send_getFreebieForItem(itemId)
3955 
    return self.recv_getFreebieForItem()
6962 rajveer 3956 
 
7190 amar.kumar 3957 
  def send_getFreebieForItem(self, itemId):
3958 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3959 
    args = getFreebieForItem_args()
3960 
    args.itemId = itemId
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_getFreebieForItem(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = getFreebieForItem_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3975 
    if result.success is not None:
3976 
      return result.success
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3978 
 
3979 
  def addOrUpdateFreebieForItem(self, freebieItem):
3980 
    """
3981 
    Parameters:
3982 
     - freebieItem
3983 
    """
3984 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3985 
    self.recv_addOrUpdateFreebieForItem()
3986 
 
3987 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3988 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3989 
    args = addOrUpdateFreebieForItem_args()
3990 
    args.freebieItem = freebieItem
3991 
    args.write(self._oprot)
3992 
    self._oprot.writeMessageEnd()
3993 
    self._oprot.trans.flush()
3994 
 
3995 
  def recv_addOrUpdateFreebieForItem(self, ):
3996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3997 
    if mtype == TMessageType.EXCEPTION:
3998 
      x = TApplicationException()
3999 
      x.read(self._iprot)
4000 
      self._iprot.readMessageEnd()
4001 
      raise x
4002 
    result = addOrUpdateFreebieForItem_result()
4003 
    result.read(self._iprot)
4004 
    self._iprot.readMessageEnd()
4005 
    return
4006 
 
7272 amit.gupta 4007 
  def addOrUpdateBrandInfo(self, brandInfo):
4008 
    """
4009 
    Parameters:
4010 
     - brandInfo
4011 
    """
4012 
    self.send_addOrUpdateBrandInfo(brandInfo)
4013 
    self.recv_addOrUpdateBrandInfo()
4014 
 
4015 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4016 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4017 
    args = addOrUpdateBrandInfo_args()
4018 
    args.brandInfo = brandInfo
4019 
    args.write(self._oprot)
4020 
    self._oprot.writeMessageEnd()
4021 
    self._oprot.trans.flush()
4022 
 
4023 
  def recv_addOrUpdateBrandInfo(self, ):
4024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4025 
    if mtype == TMessageType.EXCEPTION:
4026 
      x = TApplicationException()
4027 
      x.read(self._iprot)
4028 
      self._iprot.readMessageEnd()
4029 
      raise x
4030 
    result = addOrUpdateBrandInfo_result()
4031 
    result.read(self._iprot)
4032 
    self._iprot.readMessageEnd()
4033 
    return
4034 
 
4035 
  def getBrandInfo(self, ):
4036 
    self.send_getBrandInfo()
4037 
    return self.recv_getBrandInfo()
4038 
 
4039 
  def send_getBrandInfo(self, ):
4040 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4041 
    args = getBrandInfo_args()
4042 
    args.write(self._oprot)
4043 
    self._oprot.writeMessageEnd()
4044 
    self._oprot.trans.flush()
4045 
 
4046 
  def recv_getBrandInfo(self, ):
4047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4048 
    if mtype == TMessageType.EXCEPTION:
4049 
      x = TApplicationException()
4050 
      x.read(self._iprot)
4051 
      self._iprot.readMessageEnd()
4052 
      raise x
4053 
    result = getBrandInfo_result()
4054 
    result.read(self._iprot)
4055 
    self._iprot.readMessageEnd()
4056 
    if result.success is not None:
4057 
      return result.success
4058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4059 
 
7256 rajveer 4060 
  def getStorePricing(self, itemId):
4061 
    """
4062 
    Parameters:
4063 
     - itemId
4064 
    """
4065 
    self.send_getStorePricing(itemId)
4066 
    return self.recv_getStorePricing()
7190 amar.kumar 4067 
 
7256 rajveer 4068 
  def send_getStorePricing(self, itemId):
4069 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4070 
    args = getStorePricing_args()
4071 
    args.itemId = itemId
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_getStorePricing(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = getStorePricing_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
4088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4089 
 
7306 rajveer 4090 
  def getStorePricings(self, itemIds):
4091 
    """
4092 
    Parameters:
4093 
     - itemIds
4094 
    """
4095 
    self.send_getStorePricings(itemIds)
4096 
    return self.recv_getStorePricings()
4097 
 
4098 
  def send_getStorePricings(self, itemIds):
4099 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4100 
    args = getStorePricings_args()
4101 
    args.itemIds = itemIds
4102 
    args.write(self._oprot)
4103 
    self._oprot.writeMessageEnd()
4104 
    self._oprot.trans.flush()
4105 
 
4106 
  def recv_getStorePricings(self, ):
4107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4108 
    if mtype == TMessageType.EXCEPTION:
4109 
      x = TApplicationException()
4110 
      x.read(self._iprot)
4111 
      self._iprot.readMessageEnd()
4112 
      raise x
4113 
    result = getStorePricings_result()
4114 
    result.read(self._iprot)
4115 
    self._iprot.readMessageEnd()
4116 
    if result.success is not None:
4117 
      return result.success
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4119 
 
7382 rajveer 4120 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4121 
    """
4122 
    Parameters:
4123 
     - sp
7382 rajveer 4124 
     - allColors
7265 rajveer 4125 
    """
7382 rajveer 4126 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4127 
    self.recv_updateStorePricing()
7256 rajveer 4128 
 
7382 rajveer 4129 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4130 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4131 
    args = updateStorePricing_args()
4132 
    args.sp = sp
7382 rajveer 4133 
    args.allColors = allColors
7265 rajveer 4134 
    args.write(self._oprot)
4135 
    self._oprot.writeMessageEnd()
4136 
    self._oprot.trans.flush()
4137 
 
4138 
  def recv_updateStorePricing(self, ):
4139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4140 
    if mtype == TMessageType.EXCEPTION:
4141 
      x = TApplicationException()
4142 
      x.read(self._iprot)
4143 
      self._iprot.readMessageEnd()
4144 
      raise x
4145 
    result = updateStorePricing_result()
4146 
    result.read(self._iprot)
4147 
    self._iprot.readMessageEnd()
4148 
    return
4149 
 
7281 kshitij.so 4150 
  def getAllAmazonListedItems(self, ):
4151 
    self.send_getAllAmazonListedItems()
4152 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4153 
 
7281 kshitij.so 4154 
  def send_getAllAmazonListedItems(self, ):
4155 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4156 
    args = getAllAmazonListedItems_args()
4157 
    args.write(self._oprot)
4158 
    self._oprot.writeMessageEnd()
4159 
    self._oprot.trans.flush()
4160 
 
4161 
  def recv_getAllAmazonListedItems(self, ):
4162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4163 
    if mtype == TMessageType.EXCEPTION:
4164 
      x = TApplicationException()
4165 
      x.read(self._iprot)
4166 
      self._iprot.readMessageEnd()
4167 
      raise x
4168 
    result = getAllAmazonListedItems_result()
4169 
    result.read(self._iprot)
4170 
    self._iprot.readMessageEnd()
4171 
    if result.success is not None:
4172 
      return result.success
4173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4174 
 
8619 kshitij.so 4175 
  def searchAmazonItems(self, searchTerm, offset, limit):
4176 
    """
4177 
    Parameters:
4178 
     - searchTerm
4179 
     - offset
4180 
     - limit
4181 
    """
4182 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4183 
    return self.recv_searchAmazonItems()
4184 
 
4185 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4186 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4187 
    args = searchAmazonItems_args()
4188 
    args.searchTerm = searchTerm
4189 
    args.offset = offset
4190 
    args.limit = limit
4191 
    args.write(self._oprot)
4192 
    self._oprot.writeMessageEnd()
4193 
    self._oprot.trans.flush()
4194 
 
4195 
  def recv_searchAmazonItems(self, ):
4196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4197 
    if mtype == TMessageType.EXCEPTION:
4198 
      x = TApplicationException()
4199 
      x.read(self._iprot)
4200 
      self._iprot.readMessageEnd()
4201 
      raise x
4202 
    result = searchAmazonItems_result()
4203 
    result.read(self._iprot)
4204 
    self._iprot.readMessageEnd()
4205 
    if result.success is not None:
4206 
      return result.success
4207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4208 
 
4209 
  def getAmazonSearchResultCount(self, searchTerm):
4210 
    """
4211 
    Parameters:
4212 
     - searchTerm
4213 
    """
4214 
    self.send_getAmazonSearchResultCount(searchTerm)
4215 
    return self.recv_getAmazonSearchResultCount()
4216 
 
4217 
  def send_getAmazonSearchResultCount(self, searchTerm):
4218 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4219 
    args = getAmazonSearchResultCount_args()
4220 
    args.searchTerm = searchTerm
4221 
    args.write(self._oprot)
4222 
    self._oprot.writeMessageEnd()
4223 
    self._oprot.trans.flush()
4224 
 
4225 
  def recv_getAmazonSearchResultCount(self, ):
4226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4227 
    if mtype == TMessageType.EXCEPTION:
4228 
      x = TApplicationException()
4229 
      x.read(self._iprot)
4230 
      self._iprot.readMessageEnd()
4231 
      raise x
4232 
    result = getAmazonSearchResultCount_result()
4233 
    result.read(self._iprot)
4234 
    self._iprot.readMessageEnd()
4235 
    if result.success is not None:
4236 
      return result.success
4237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4238 
 
4239 
  def getCountForAmazonlistedItems(self, ):
4240 
    self.send_getCountForAmazonlistedItems()
4241 
    return self.recv_getCountForAmazonlistedItems()
4242 
 
4243 
  def send_getCountForAmazonlistedItems(self, ):
4244 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4245 
    args = getCountForAmazonlistedItems_args()
4246 
    args.write(self._oprot)
4247 
    self._oprot.writeMessageEnd()
4248 
    self._oprot.trans.flush()
4249 
 
4250 
  def recv_getCountForAmazonlistedItems(self, ):
4251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4252 
    if mtype == TMessageType.EXCEPTION:
4253 
      x = TApplicationException()
4254 
      x.read(self._iprot)
4255 
      self._iprot.readMessageEnd()
4256 
      raise x
4257 
    result = getCountForAmazonlistedItems_result()
4258 
    result.read(self._iprot)
4259 
    self._iprot.readMessageEnd()
4260 
    if result.success is not None:
4261 
      return result.success
4262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4263 
 
7281 kshitij.so 4264 
  def getAmazonItemDetails(self, itemId):
4265 
    """
4266 
    Parameters:
4267 
     - itemId
4268 
    """
4269 
    self.send_getAmazonItemDetails(itemId)
4270 
    return self.recv_getAmazonItemDetails()
4271 
 
4272 
  def send_getAmazonItemDetails(self, itemId):
4273 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4274 
    args = getAmazonItemDetails_args()
4275 
    args.itemId = itemId
4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_getAmazonItemDetails(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = getAmazonItemDetails_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.success is not None:
4291 
      return result.success
4292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4293 
 
8168 kshitij.so 4294 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4295 
    """
4296 
    Parameters:
8168 kshitij.so 4297 
     - amazonlisted
7281 kshitij.so 4298 
    """
8168 kshitij.so 4299 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4300 
    self.recv_updateAmazonItemDetails()
4301 
 
8168 kshitij.so 4302 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4303 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4304 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4305 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4306 
    args.write(self._oprot)
4307 
    self._oprot.writeMessageEnd()
4308 
    self._oprot.trans.flush()
4309 
 
4310 
  def recv_updateAmazonItemDetails(self, ):
4311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4312 
    if mtype == TMessageType.EXCEPTION:
4313 
      x = TApplicationException()
4314 
      x.read(self._iprot)
4315 
      self._iprot.readMessageEnd()
4316 
      raise x
4317 
    result = updateAmazonItemDetails_result()
4318 
    result.read(self._iprot)
4319 
    self._iprot.readMessageEnd()
4320 
    return
4321 
 
4322 
  def addAmazonItem(self, amazonlisted):
4323 
    """
4324 
    Parameters:
4325 
     - amazonlisted
4326 
    """
4327 
    self.send_addAmazonItem(amazonlisted)
4328 
    self.recv_addAmazonItem()
4329 
 
4330 
  def send_addAmazonItem(self, amazonlisted):
4331 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4332 
    args = addAmazonItem_args()
4333 
    args.amazonlisted = amazonlisted
4334 
    args.write(self._oprot)
4335 
    self._oprot.writeMessageEnd()
4336 
    self._oprot.trans.flush()
4337 
 
4338 
  def recv_addAmazonItem(self, ):
4339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4340 
    if mtype == TMessageType.EXCEPTION:
4341 
      x = TApplicationException()
4342 
      x.read(self._iprot)
4343 
      self._iprot.readMessageEnd()
4344 
      raise x
4345 
    result = addAmazonItem_result()
4346 
    result.read(self._iprot)
4347 
    self._iprot.readMessageEnd()
4348 
    return
4349 
 
7291 vikram.rag 4350 
  def getAsinItems(self, ):
4351 
    self.send_getAsinItems()
4352 
    return self.recv_getAsinItems()
7281 kshitij.so 4353 
 
7291 vikram.rag 4354 
  def send_getAsinItems(self, ):
4355 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4356 
    args = getAsinItems_args()
4357 
    args.write(self._oprot)
4358 
    self._oprot.writeMessageEnd()
4359 
    self._oprot.trans.flush()
4360 
 
4361 
  def recv_getAsinItems(self, ):
4362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4363 
    if mtype == TMessageType.EXCEPTION:
4364 
      x = TApplicationException()
4365 
      x.read(self._iprot)
4366 
      self._iprot.readMessageEnd()
4367 
      raise x
4368 
    result = getAsinItems_result()
4369 
    result.read(self._iprot)
4370 
    self._iprot.readMessageEnd()
4371 
    if result.success is not None:
4372 
      return result.success
4373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4374 
 
4375 
  def getAllFbaListedItems(self, ):
4376 
    self.send_getAllFbaListedItems()
4377 
    return self.recv_getAllFbaListedItems()
4378 
 
4379 
  def send_getAllFbaListedItems(self, ):
4380 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4381 
    args = getAllFbaListedItems_args()
4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_getAllFbaListedItems(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = getAllFbaListedItems_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    if result.success is not None:
4397 
      return result.success
4398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4399 
 
4400 
  def getAllNonFbaListedItems(self, ):
4401 
    self.send_getAllNonFbaListedItems()
4402 
    return self.recv_getAllNonFbaListedItems()
4403 
 
4404 
  def send_getAllNonFbaListedItems(self, ):
4405 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4406 
    args = getAllNonFbaListedItems_args()
4407 
    args.write(self._oprot)
4408 
    self._oprot.writeMessageEnd()
4409 
    self._oprot.trans.flush()
4410 
 
4411 
  def recv_getAllNonFbaListedItems(self, ):
4412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4413 
    if mtype == TMessageType.EXCEPTION:
4414 
      x = TApplicationException()
4415 
      x.read(self._iprot)
4416 
      self._iprot.readMessageEnd()
4417 
      raise x
4418 
    result = getAllNonFbaListedItems_result()
4419 
    result.read(self._iprot)
4420 
    self._iprot.readMessageEnd()
4421 
    if result.success is not None:
4422 
      return result.success
4423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4424 
 
7460 kshitij.so 4425 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4426 
    """
4427 
    Parameters:
4428 
     - itemId
4429 
     - holdInventory
4430 
     - defaultInventory
4431 
    """
4432 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4433 
    return self.recv_updateItemInventory()
7291 vikram.rag 4434 
 
7460 kshitij.so 4435 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4436 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4437 
    args = updateItemInventory_args()
4438 
    args.itemId = itemId
4439 
    args.holdInventory = holdInventory
4440 
    args.defaultInventory = defaultInventory
4441 
    args.write(self._oprot)
4442 
    self._oprot.writeMessageEnd()
4443 
    self._oprot.trans.flush()
4444 
 
4445 
  def recv_updateItemInventory(self, ):
4446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4447 
    if mtype == TMessageType.EXCEPTION:
4448 
      x = TApplicationException()
4449 
      x.read(self._iprot)
4450 
      self._iprot.readMessageEnd()
4451 
      raise x
4452 
    result = updateItemInventory_result()
4453 
    result.read(self._iprot)
4454 
    self._iprot.readMessageEnd()
4455 
    if result.success is not None:
4456 
      return result.success
4457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4458 
 
7770 kshitij.so 4459 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4460 
    """
4461 
    Parameters:
4462 
     - type
4463 
     - sku
4464 
     - timestamp
4465 
    """
4466 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4467 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4468 
 
7770 kshitij.so 4469 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4470 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4471 
    args = updateTimestampForAmazonFeeds_args()
4472 
    args.type = type
4473 
    args.sku = sku
4474 
    args.timestamp = timestamp
4475 
    args.write(self._oprot)
4476 
    self._oprot.writeMessageEnd()
4477 
    self._oprot.trans.flush()
4478 
 
4479 
  def recv_updateTimestampForAmazonFeeds(self, ):
4480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4481 
    if mtype == TMessageType.EXCEPTION:
4482 
      x = TApplicationException()
4483 
      x.read(self._iprot)
4484 
      self._iprot.readMessageEnd()
4485 
      raise x
4486 
    result = updateTimestampForAmazonFeeds_result()
4487 
    result.read(self._iprot)
4488 
    self._iprot.readMessageEnd()
4489 
    if result.success is not None:
4490 
      return result.success
4491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4492 
 
7897 amar.kumar 4493 
  def getAllParentCategories(self, ):
4494 
    self.send_getAllParentCategories()
4495 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4496 
 
7897 amar.kumar 4497 
  def send_getAllParentCategories(self, ):
4498 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4499 
    args = getAllParentCategories_args()
4500 
    args.write(self._oprot)
4501 
    self._oprot.writeMessageEnd()
4502 
    self._oprot.trans.flush()
4503 
 
4504 
  def recv_getAllParentCategories(self, ):
4505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4506 
    if mtype == TMessageType.EXCEPTION:
4507 
      x = TApplicationException()
4508 
      x.read(self._iprot)
4509 
      self._iprot.readMessageEnd()
4510 
      raise x
4511 
    result = getAllParentCategories_result()
4512 
    result.read(self._iprot)
4513 
    self._iprot.readMessageEnd()
4514 
    if result.success is not None:
4515 
      return result.success
4516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4517 
 
7977 kshitij.so 4518 
  def addPageViewEvent(self, pageViewEvents):
4519 
    """
4520 
    Parameters:
4521 
     - pageViewEvents
4522 
    """
4523 
    self.send_addPageViewEvent(pageViewEvents)
4524 
    self.recv_addPageViewEvent()
7897 amar.kumar 4525 
 
7977 kshitij.so 4526 
  def send_addPageViewEvent(self, pageViewEvents):
4527 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4528 
    args = addPageViewEvent_args()
4529 
    args.pageViewEvents = pageViewEvents
4530 
    args.write(self._oprot)
4531 
    self._oprot.writeMessageEnd()
4532 
    self._oprot.trans.flush()
4533 
 
4534 
  def recv_addPageViewEvent(self, ):
4535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4536 
    if mtype == TMessageType.EXCEPTION:
4537 
      x = TApplicationException()
4538 
      x.read(self._iprot)
4539 
      self._iprot.readMessageEnd()
4540 
      raise x
4541 
    result = addPageViewEvent_result()
4542 
    result.read(self._iprot)
4543 
    self._iprot.readMessageEnd()
4544 
    return
4545 
 
4546 
  def addCartEvent(self, cartEvents):
4547 
    """
4548 
    Parameters:
4549 
     - cartEvents
4550 
    """
4551 
    self.send_addCartEvent(cartEvents)
4552 
    self.recv_addCartEvent()
4553 
 
4554 
  def send_addCartEvent(self, cartEvents):
4555 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4556 
    args = addCartEvent_args()
4557 
    args.cartEvents = cartEvents
4558 
    args.write(self._oprot)
4559 
    self._oprot.writeMessageEnd()
4560 
    self._oprot.trans.flush()
4561 
 
4562 
  def recv_addCartEvent(self, ):
4563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4564 
    if mtype == TMessageType.EXCEPTION:
4565 
      x = TApplicationException()
4566 
      x.read(self._iprot)
4567 
      self._iprot.readMessageEnd()
4568 
      raise x
4569 
    result = addCartEvent_result()
4570 
    result.read(self._iprot)
4571 
    self._iprot.readMessageEnd()
4572 
    return
4573 
 
8182 amar.kumar 4574 
  def addEbayItem(self, ebayItem):
4575 
    """
4576 
    Parameters:
4577 
     - ebayItem
4578 
    """
4579 
    self.send_addEbayItem(ebayItem)
4580 
    self.recv_addEbayItem()
4581 
 
4582 
  def send_addEbayItem(self, ebayItem):
4583 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4584 
    args = addEbayItem_args()
4585 
    args.ebayItem = ebayItem
4586 
    args.write(self._oprot)
4587 
    self._oprot.writeMessageEnd()
4588 
    self._oprot.trans.flush()
4589 
 
4590 
  def recv_addEbayItem(self, ):
4591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4592 
    if mtype == TMessageType.EXCEPTION:
4593 
      x = TApplicationException()
4594 
      x.read(self._iprot)
4595 
      self._iprot.readMessageEnd()
4596 
      raise x
4597 
    result = addEbayItem_result()
4598 
    result.read(self._iprot)
4599 
    self._iprot.readMessageEnd()
4600 
    return
4601 
 
4602 
  def getEbayItem(self, listingId):
4603 
    """
4604 
    Parameters:
4605 
     - listingId
4606 
    """
4607 
    self.send_getEbayItem(listingId)
4608 
    return self.recv_getEbayItem()
4609 
 
4610 
  def send_getEbayItem(self, listingId):
4611 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4612 
    args = getEbayItem_args()
4613 
    args.listingId = listingId
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_getEbayItem(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = getEbayItem_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.success is not None:
4629 
      return result.success
4630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4631 
 
4632 
  def updateEbayItem(self, ebayItem):
4633 
    """
4634 
    Parameters:
4635 
     - ebayItem
4636 
    """
4637 
    self.send_updateEbayItem(ebayItem)
4638 
    self.recv_updateEbayItem()
4639 
 
4640 
  def send_updateEbayItem(self, ebayItem):
4641 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4642 
    args = updateEbayItem_args()
4643 
    args.ebayItem = ebayItem
4644 
    args.write(self._oprot)
4645 
    self._oprot.writeMessageEnd()
4646 
    self._oprot.trans.flush()
4647 
 
4648 
  def recv_updateEbayItem(self, ):
4649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4650 
    if mtype == TMessageType.EXCEPTION:
4651 
      x = TApplicationException()
4652 
      x.read(self._iprot)
4653 
      self._iprot.readMessageEnd()
4654 
      raise x
4655 
    result = updateEbayItem_result()
4656 
    result.read(self._iprot)
4657 
    self._iprot.readMessageEnd()
4658 
    return
4659 
 
8139 kshitij.so 4660 
  def getAmazonListedItems(self, offset, limit):
4661 
    """
4662 
    Parameters:
4663 
     - offset
4664 
     - limit
4665 
    """
4666 
    self.send_getAmazonListedItems(offset, limit)
4667 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4668 
 
8139 kshitij.so 4669 
  def send_getAmazonListedItems(self, offset, limit):
4670 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4671 
    args = getAmazonListedItems_args()
4672 
    args.offset = offset
4673 
    args.limit = limit
4674 
    args.write(self._oprot)
4675 
    self._oprot.writeMessageEnd()
4676 
    self._oprot.trans.flush()
4677 
 
4678 
  def recv_getAmazonListedItems(self, ):
4679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4680 
    if mtype == TMessageType.EXCEPTION:
4681 
      x = TApplicationException()
4682 
      x.read(self._iprot)
4683 
      self._iprot.readMessageEnd()
4684 
      raise x
4685 
    result = getAmazonListedItems_result()
4686 
    result.read(self._iprot)
4687 
    self._iprot.readMessageEnd()
4688 
    if result.success is not None:
4689 
      return result.success
4690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4691 
 
8168 kshitij.so 4692 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4693 
    """
4694 
    Parameters:
4695 
     - amazonlisted
4696 
    """
4697 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4698 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4699 
 
8168 kshitij.so 4700 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4701 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4702 
    args = updateAmazonAttributesInBulk_args()
4703 
    args.amazonlisted = amazonlisted
4704 
    args.write(self._oprot)
4705 
    self._oprot.writeMessageEnd()
4706 
    self._oprot.trans.flush()
4707 
 
4708 
  def recv_updateAmazonAttributesInBulk(self, ):
4709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4710 
    if mtype == TMessageType.EXCEPTION:
4711 
      x = TApplicationException()
4712 
      x.read(self._iprot)
4713 
      self._iprot.readMessageEnd()
4714 
      raise x
4715 
    result = updateAmazonAttributesInBulk_result()
4716 
    result.read(self._iprot)
4717 
    self._iprot.readMessageEnd()
4718 
    if result.success is not None:
4719 
      return result.success
4720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4721 
 
8379 vikram.rag 4722 
  def getAllItemstoListOnFba(self, ):
4723 
    self.send_getAllItemstoListOnFba()
4724 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4725 
 
8379 vikram.rag 4726 
  def send_getAllItemstoListOnFba(self, ):
4727 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4728 
    args = getAllItemstoListOnFba_args()
4729 
    args.write(self._oprot)
4730 
    self._oprot.writeMessageEnd()
4731 
    self._oprot.trans.flush()
4732 
 
4733 
  def recv_getAllItemstoListOnFba(self, ):
4734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4735 
    if mtype == TMessageType.EXCEPTION:
4736 
      x = TApplicationException()
4737 
      x.read(self._iprot)
4738 
      self._iprot.readMessageEnd()
4739 
      raise x
4740 
    result = getAllItemstoListOnFba_result()
4741 
    result.read(self._iprot)
4742 
    self._iprot.readMessageEnd()
4743 
    if result.success is not None:
4744 
      return result.success
4745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4746 
 
4747 
  def getAllItemstoListOnNonFba(self, ):
4748 
    self.send_getAllItemstoListOnNonFba()
4749 
    return self.recv_getAllItemstoListOnNonFba()
4750 
 
4751 
  def send_getAllItemstoListOnNonFba(self, ):
4752 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4753 
    args = getAllItemstoListOnNonFba_args()
4754 
    args.write(self._oprot)
4755 
    self._oprot.writeMessageEnd()
4756 
    self._oprot.trans.flush()
4757 
 
4758 
  def recv_getAllItemstoListOnNonFba(self, ):
4759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4760 
    if mtype == TMessageType.EXCEPTION:
4761 
      x = TApplicationException()
4762 
      x.read(self._iprot)
4763 
      self._iprot.readMessageEnd()
4764 
      raise x
4765 
    result = getAllItemstoListOnNonFba_result()
4766 
    result.read(self._iprot)
4767 
    self._iprot.readMessageEnd()
4768 
    if result.success is not None:
4769 
      return result.success
4770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4771 
 
8619 kshitij.so 4772 
  def updateAsin(self, item):
4773 
    """
4774 
    Parameters:
4775 
     - item
4776 
    """
4777 
    self.send_updateAsin(item)
4778 
    self.recv_updateAsin()
8616 vikram.rag 4779 
 
8619 kshitij.so 4780 
  def send_updateAsin(self, item):
4781 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4782 
    args = updateAsin_args()
4783 
    args.item = item
4784 
    args.write(self._oprot)
4785 
    self._oprot.writeMessageEnd()
4786 
    self._oprot.trans.flush()
4787 
 
4788 
  def recv_updateAsin(self, ):
4789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4790 
    if mtype == TMessageType.EXCEPTION:
4791 
      x = TApplicationException()
4792 
      x.read(self._iprot)
4793 
      self._iprot.readMessageEnd()
4794 
      raise x
4795 
    result = updateAsin_result()
4796 
    result.read(self._iprot)
4797 
    self._iprot.readMessageEnd()
4798 
    return
4799 
 
8739 vikram.rag 4800 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4801 
    """
4802 
    Parameters:
4803 
     - snapdealitem
4804 
    """
4805 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4806 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4807 
 
8739 vikram.rag 4808 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4809 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4810 
    args = addOrUpdateSnapdealItem_args()
4811 
    args.snapdealitem = snapdealitem
4812 
    args.write(self._oprot)
4813 
    self._oprot.writeMessageEnd()
4814 
    self._oprot.trans.flush()
4815 
 
4816 
  def recv_addOrUpdateSnapdealItem(self, ):
4817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4818 
    if mtype == TMessageType.EXCEPTION:
4819 
      x = TApplicationException()
4820 
      x.read(self._iprot)
4821 
      self._iprot.readMessageEnd()
4822 
      raise x
4823 
    result = addOrUpdateSnapdealItem_result()
4824 
    result.read(self._iprot)
4825 
    self._iprot.readMessageEnd()
4826 
    if result.success is not None:
4827 
      return result.success
4828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4829 
 
4830 
  def getSnapdealItem(self, item_id):
4831 
    """
4832 
    Parameters:
4833 
     - item_id
4834 
    """
4835 
    self.send_getSnapdealItem(item_id)
4836 
    return self.recv_getSnapdealItem()
4837 
 
4838 
  def send_getSnapdealItem(self, item_id):
4839 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4840 
    args = getSnapdealItem_args()
4841 
    args.item_id = item_id
4842 
    args.write(self._oprot)
4843 
    self._oprot.writeMessageEnd()
4844 
    self._oprot.trans.flush()
4845 
 
4846 
  def recv_getSnapdealItem(self, ):
4847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4848 
    if mtype == TMessageType.EXCEPTION:
4849 
      x = TApplicationException()
4850 
      x.read(self._iprot)
4851 
      self._iprot.readMessageEnd()
4852 
      raise x
4853 
    result = getSnapdealItem_result()
4854 
    result.read(self._iprot)
4855 
    self._iprot.readMessageEnd()
4856 
    if result.success is not None:
4857 
      return result.success
4858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4859 
 
9242 kshitij.so 4860 
  def getSnapdealItemDetails(self, item_id):
4861 
    """
4862 
    Parameters:
4863 
     - item_id
4864 
    """
4865 
    self.send_getSnapdealItemDetails(item_id)
4866 
    return self.recv_getSnapdealItemDetails()
4867 
 
4868 
  def send_getSnapdealItemDetails(self, item_id):
4869 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4870 
    args = getSnapdealItemDetails_args()
4871 
    args.item_id = item_id
4872 
    args.write(self._oprot)
4873 
    self._oprot.writeMessageEnd()
4874 
    self._oprot.trans.flush()
4875 
 
4876 
  def recv_getSnapdealItemDetails(self, ):
4877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4878 
    if mtype == TMessageType.EXCEPTION:
4879 
      x = TApplicationException()
4880 
      x.read(self._iprot)
4881 
      self._iprot.readMessageEnd()
4882 
      raise x
4883 
    result = getSnapdealItemDetails_result()
4884 
    result.read(self._iprot)
4885 
    self._iprot.readMessageEnd()
4886 
    if result.success is not None:
4887 
      return result.success
4888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4889 
 
8739 vikram.rag 4890 
  def getAllSnapdealItems(self, ):
4891 
    self.send_getAllSnapdealItems()
4892 
    return self.recv_getAllSnapdealItems()
4893 
 
4894 
  def send_getAllSnapdealItems(self, ):
4895 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4896 
    args = getAllSnapdealItems_args()
4897 
    args.write(self._oprot)
4898 
    self._oprot.writeMessageEnd()
4899 
    self._oprot.trans.flush()
4900 
 
4901 
  def recv_getAllSnapdealItems(self, ):
4902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4903 
    if mtype == TMessageType.EXCEPTION:
4904 
      x = TApplicationException()
4905 
      x.read(self._iprot)
4906 
      self._iprot.readMessageEnd()
4907 
      raise x
4908 
    result = getAllSnapdealItems_result()
4909 
    result.read(self._iprot)
4910 
    self._iprot.readMessageEnd()
4911 
    if result.success is not None:
4912 
      return result.success
4913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4914 
 
9242 kshitij.so 4915 
  def getSnapdealItems(self, offset, limit):
4916 
    """
4917 
    Parameters:
4918 
     - offset
4919 
     - limit
4920 
    """
4921 
    self.send_getSnapdealItems(offset, limit)
4922 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4923 
 
9242 kshitij.so 4924 
  def send_getSnapdealItems(self, offset, limit):
4925 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4926 
    args = getSnapdealItems_args()
4927 
    args.offset = offset
4928 
    args.limit = limit
4929 
    args.write(self._oprot)
4930 
    self._oprot.writeMessageEnd()
4931 
    self._oprot.trans.flush()
4932 
 
4933 
  def recv_getSnapdealItems(self, ):
4934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4935 
    if mtype == TMessageType.EXCEPTION:
4936 
      x = TApplicationException()
4937 
      x.read(self._iprot)
4938 
      self._iprot.readMessageEnd()
4939 
      raise x
4940 
    result = getSnapdealItems_result()
4941 
    result.read(self._iprot)
4942 
    self._iprot.readMessageEnd()
4943 
    if result.success is not None:
4944 
      return result.success
4945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4946 
 
4947 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4948 
    """
4949 
    Parameters:
4950 
     - searchTerm
4951 
     - offset
4952 
     - limit
4953 
    """
4954 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4955 
    return self.recv_searchSnapdealItems()
4956 
 
4957 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4958 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4959 
    args = searchSnapdealItems_args()
4960 
    args.searchTerm = searchTerm
4961 
    args.offset = offset
4962 
    args.limit = limit
4963 
    args.write(self._oprot)
4964 
    self._oprot.writeMessageEnd()
4965 
    self._oprot.trans.flush()
4966 
 
4967 
  def recv_searchSnapdealItems(self, ):
4968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4969 
    if mtype == TMessageType.EXCEPTION:
4970 
      x = TApplicationException()
4971 
      x.read(self._iprot)
4972 
      self._iprot.readMessageEnd()
4973 
      raise x
4974 
    result = searchSnapdealItems_result()
4975 
    result.read(self._iprot)
4976 
    self._iprot.readMessageEnd()
4977 
    if result.success is not None:
4978 
      return result.success
4979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4980 
 
4981 
  def getCountForSnapdealItems(self, ):
4982 
    self.send_getCountForSnapdealItems()
4983 
    return self.recv_getCountForSnapdealItems()
4984 
 
4985 
  def send_getCountForSnapdealItems(self, ):
4986 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4987 
    args = getCountForSnapdealItems_args()
4988 
    args.write(self._oprot)
4989 
    self._oprot.writeMessageEnd()
4990 
    self._oprot.trans.flush()
4991 
 
4992 
  def recv_getCountForSnapdealItems(self, ):
4993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4994 
    if mtype == TMessageType.EXCEPTION:
4995 
      x = TApplicationException()
4996 
      x.read(self._iprot)
4997 
      self._iprot.readMessageEnd()
4998 
      raise x
4999 
    result = getCountForSnapdealItems_result()
5000 
    result.read(self._iprot)
5001 
    self._iprot.readMessageEnd()
5002 
    if result.success is not None:
5003 
      return result.success
5004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5005 
 
5006 
  def getSnapdealSearchResultCount(self, searchTerm):
5007 
    """
5008 
    Parameters:
5009 
     - searchTerm
5010 
    """
5011 
    self.send_getSnapdealSearchResultCount(searchTerm)
5012 
    return self.recv_getSnapdealSearchResultCount()
5013 
 
5014 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5015 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5016 
    args = getSnapdealSearchResultCount_args()
5017 
    args.searchTerm = searchTerm
5018 
    args.write(self._oprot)
5019 
    self._oprot.writeMessageEnd()
5020 
    self._oprot.trans.flush()
5021 
 
5022 
  def recv_getSnapdealSearchResultCount(self, ):
5023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5024 
    if mtype == TMessageType.EXCEPTION:
5025 
      x = TApplicationException()
5026 
      x.read(self._iprot)
5027 
      self._iprot.readMessageEnd()
5028 
      raise x
5029 
    result = getSnapdealSearchResultCount_result()
5030 
    result.read(self._iprot)
5031 
    self._iprot.readMessageEnd()
5032 
    if result.success is not None:
5033 
      return result.success
5034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5035 
 
9299 kshitij.so 5036 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5037 
    """
5038 
    Parameters:
5039 
     - itemId
5040 
     - insurerType
5041 
    """
5042 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5043 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5044 
 
9299 kshitij.so 5045 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5046 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5047 
    args = getPrefferedInsurerForItem_args()
5048 
    args.itemId = itemId
5049 
    args.insurerType = insurerType
5050 
    args.write(self._oprot)
5051 
    self._oprot.writeMessageEnd()
5052 
    self._oprot.trans.flush()
5053 
 
5054 
  def recv_getPrefferedInsurerForItem(self, ):
5055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5056 
    if mtype == TMessageType.EXCEPTION:
5057 
      x = TApplicationException()
5058 
      x.read(self._iprot)
5059 
      self._iprot.readMessageEnd()
5060 
      raise x
5061 
    result = getPrefferedInsurerForItem_result()
5062 
    result.read(self._iprot)
5063 
    self._iprot.readMessageEnd()
5064 
    if result.success is not None:
5065 
      return result.success
5066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5067 
 
9456 vikram.rag 5068 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5069 
    """
5070 
    Parameters:
5071 
     - skuAtSnapdeal
5072 
    """
5073 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5074 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5075 
 
9456 vikram.rag 5076 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5077 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5078 
    args = getSnapdealItembySkuAtSnapdeal_args()
5079 
    args.skuAtSnapdeal = skuAtSnapdeal
5080 
    args.write(self._oprot)
5081 
    self._oprot.writeMessageEnd()
5082 
    self._oprot.trans.flush()
5083 
 
5084 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5086 
    if mtype == TMessageType.EXCEPTION:
5087 
      x = TApplicationException()
5088 
      x.read(self._iprot)
5089 
      self._iprot.readMessageEnd()
5090 
      raise x
5091 
    result = getSnapdealItembySkuAtSnapdeal_result()
5092 
    result.read(self._iprot)
5093 
    self._iprot.readMessageEnd()
5094 
    if result.success is not None:
5095 
      return result.success
5096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5097 
 
9621 manish.sha 5098 
  def getProductFeedSubmit(self, catalogItemId):
5099 
    """
5100 
    Parameters:
5101 
     - catalogItemId
5102 
    """
5103 
    self.send_getProductFeedSubmit(catalogItemId)
5104 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5105 
 
9621 manish.sha 5106 
  def send_getProductFeedSubmit(self, catalogItemId):
5107 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5108 
    args = getProductFeedSubmit_args()
5109 
    args.catalogItemId = catalogItemId
5110 
    args.write(self._oprot)
5111 
    self._oprot.writeMessageEnd()
5112 
    self._oprot.trans.flush()
5113 
 
5114 
  def recv_getProductFeedSubmit(self, ):
5115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5116 
    if mtype == TMessageType.EXCEPTION:
5117 
      x = TApplicationException()
5118 
      x.read(self._iprot)
5119 
      self._iprot.readMessageEnd()
5120 
      raise x
5121 
    result = getProductFeedSubmit_result()
5122 
    result.read(self._iprot)
5123 
    self._iprot.readMessageEnd()
5124 
    if result.success is not None:
5125 
      return result.success
5126 
    if result.cex is not None:
5127 
      raise result.cex
5128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5129 
 
5130 
  def addProductFeedSubmit(self, productFeedSubmit):
5131 
    """
5132 
    Parameters:
5133 
     - productFeedSubmit
5134 
    """
5135 
    self.send_addProductFeedSubmit(productFeedSubmit)
5136 
    return self.recv_addProductFeedSubmit()
5137 
 
5138 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5139 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5140 
    args = addProductFeedSubmit_args()
5141 
    args.productFeedSubmit = productFeedSubmit
5142 
    args.write(self._oprot)
5143 
    self._oprot.writeMessageEnd()
5144 
    self._oprot.trans.flush()
5145 
 
5146 
  def recv_addProductFeedSubmit(self, ):
5147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5148 
    if mtype == TMessageType.EXCEPTION:
5149 
      x = TApplicationException()
5150 
      x.read(self._iprot)
5151 
      self._iprot.readMessageEnd()
5152 
      raise x
5153 
    result = addProductFeedSubmit_result()
5154 
    result.read(self._iprot)
5155 
    self._iprot.readMessageEnd()
5156 
    if result.success is not None:
5157 
      return result.success
5158 
    if result.cex is not None:
5159 
      raise result.cex
5160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5161 
 
5162 
  def updateProductFeedSubmit(self, productFeedSubmit):
5163 
    """
5164 
    Parameters:
5165 
     - productFeedSubmit
5166 
    """
5167 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5168 
    return self.recv_updateProductFeedSubmit()
5169 
 
5170 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5171 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5172 
    args = updateProductFeedSubmit_args()
5173 
    args.productFeedSubmit = productFeedSubmit
5174 
    args.write(self._oprot)
5175 
    self._oprot.writeMessageEnd()
5176 
    self._oprot.trans.flush()
5177 
 
5178 
  def recv_updateProductFeedSubmit(self, ):
5179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5180 
    if mtype == TMessageType.EXCEPTION:
5181 
      x = TApplicationException()
5182 
      x.read(self._iprot)
5183 
      self._iprot.readMessageEnd()
5184 
      raise x
5185 
    result = updateProductFeedSubmit_result()
5186 
    result.read(self._iprot)
5187 
    self._iprot.readMessageEnd()
5188 
    if result.success is not None:
5189 
      return result.success
5190 
    if result.cex is not None:
5191 
      raise result.cex
5192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5193 
 
5194 
  def deleteProductFeedSubmit(self, catalogItemId):
5195 
    """
5196 
    Parameters:
5197 
     - catalogItemId
5198 
    """
5199 
    self.send_deleteProductFeedSubmit(catalogItemId)
5200 
    return self.recv_deleteProductFeedSubmit()
5201 
 
5202 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5203 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5204 
    args = deleteProductFeedSubmit_args()
5205 
    args.catalogItemId = catalogItemId
5206 
    args.write(self._oprot)
5207 
    self._oprot.writeMessageEnd()
5208 
    self._oprot.trans.flush()
5209 
 
5210 
  def recv_deleteProductFeedSubmit(self, ):
5211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5212 
    if mtype == TMessageType.EXCEPTION:
5213 
      x = TApplicationException()
5214 
      x.read(self._iprot)
5215 
      self._iprot.readMessageEnd()
5216 
      raise x
5217 
    result = deleteProductFeedSubmit_result()
5218 
    result.read(self._iprot)
5219 
    self._iprot.readMessageEnd()
5220 
    if result.success is not None:
5221 
      return result.success
5222 
    if result.cex is not None:
5223 
      raise result.cex
5224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5225 
 
5226 
  def getAllProductFeedSubmit(self, ):
5227 
    self.send_getAllProductFeedSubmit()
5228 
    return self.recv_getAllProductFeedSubmit()
5229 
 
5230 
  def send_getAllProductFeedSubmit(self, ):
5231 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5232 
    args = getAllProductFeedSubmit_args()
5233 
    args.write(self._oprot)
5234 
    self._oprot.writeMessageEnd()
5235 
    self._oprot.trans.flush()
5236 
 
5237 
  def recv_getAllProductFeedSubmit(self, ):
5238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5239 
    if mtype == TMessageType.EXCEPTION:
5240 
      x = TApplicationException()
5241 
      x.read(self._iprot)
5242 
      self._iprot.readMessageEnd()
5243 
      raise x
5244 
    result = getAllProductFeedSubmit_result()
5245 
    result.read(self._iprot)
5246 
    self._iprot.readMessageEnd()
5247 
    if result.success is not None:
5248 
      return result.success
5249 
    if result.cex is not None:
5250 
      raise result.cex
5251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5252 
 
9724 kshitij.so 5253 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5254 
    """
5255 
    Parameters:
5256 
     - itemId
5257 
     - sourceId
5258 
    """
5259 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5260 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5261 
 
9724 kshitij.so 5262 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5263 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5264 
    args = getMarketplacedetailsForItem_args()
5265 
    args.itemId = itemId
5266 
    args.sourceId = sourceId
5267 
    args.write(self._oprot)
5268 
    self._oprot.writeMessageEnd()
5269 
    self._oprot.trans.flush()
5270 
 
5271 
  def recv_getMarketplacedetailsForItem(self, ):
5272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5273 
    if mtype == TMessageType.EXCEPTION:
5274 
      x = TApplicationException()
5275 
      x.read(self._iprot)
5276 
      self._iprot.readMessageEnd()
5277 
      raise x
5278 
    result = getMarketplacedetailsForItem_result()
5279 
    result.read(self._iprot)
5280 
    self._iprot.readMessageEnd()
5281 
    if result.success is not None:
5282 
      return result.success
5283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5284 
 
5285 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5286 
    """
5287 
    Parameters:
5288 
     - marketPlaceItem
5289 
    """
5290 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5291 
    return self.recv_updateMarketplaceAttributesForItem()
5292 
 
5293 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5294 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5295 
    args = updateMarketplaceAttributesForItem_args()
5296 
    args.marketPlaceItem = marketPlaceItem
5297 
    args.write(self._oprot)
5298 
    self._oprot.writeMessageEnd()
5299 
    self._oprot.trans.flush()
5300 
 
5301 
  def recv_updateMarketplaceAttributesForItem(self, ):
5302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5303 
    if mtype == TMessageType.EXCEPTION:
5304 
      x = TApplicationException()
5305 
      x.read(self._iprot)
5306 
      self._iprot.readMessageEnd()
5307 
      raise x
5308 
    result = updateMarketplaceAttributesForItem_result()
5309 
    result.read(self._iprot)
5310 
    self._iprot.readMessageEnd()
5311 
    if result.success is not None:
5312 
      return result.success
5313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5314 
 
9779 kshitij.so 5315 
  def getCostingForMarketplace(self, source, item_id):
5316 
    """
5317 
    Parameters:
5318 
     - source
5319 
     - item_id
5320 
    """
5321 
    self.send_getCostingForMarketplace(source, item_id)
5322 
    return self.recv_getCostingForMarketplace()
5323 
 
5324 
  def send_getCostingForMarketplace(self, source, item_id):
5325 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5326 
    args = getCostingForMarketplace_args()
5327 
    args.source = source
5328 
    args.item_id = item_id
5329 
    args.write(self._oprot)
5330 
    self._oprot.writeMessageEnd()
5331 
    self._oprot.trans.flush()
5332 
 
5333 
  def recv_getCostingForMarketplace(self, ):
5334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5335 
    if mtype == TMessageType.EXCEPTION:
5336 
      x = TApplicationException()
5337 
      x.read(self._iprot)
5338 
      self._iprot.readMessageEnd()
5339 
      raise x
5340 
    result = getCostingForMarketplace_result()
5341 
    result.read(self._iprot)
5342 
    self._iprot.readMessageEnd()
5343 
    if result.success is not None:
5344 
      return result.success
5345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5346 
 
9776 vikram.rag 5347 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5348 
    """
5349 
    Parameters:
5350 
     - source
5351 
    """
5352 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5353 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5354 
 
9776 vikram.rag 5355 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5356 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5357 
    args = getMarketPlaceItemsForPriceUpdate_args()
5358 
    args.source = source
5359 
    args.write(self._oprot)
5360 
    self._oprot.writeMessageEnd()
5361 
    self._oprot.trans.flush()
5362 
 
5363 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5365 
    if mtype == TMessageType.EXCEPTION:
5366 
      x = TApplicationException()
5367 
      x.read(self._iprot)
5368 
      self._iprot.readMessageEnd()
5369 
      raise x
5370 
    result = getMarketPlaceItemsForPriceUpdate_result()
5371 
    result.read(self._iprot)
5372 
    self._iprot.readMessageEnd()
5373 
    if result.success is not None:
5374 
      return result.success
5375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5376 
 
9816 kshitij.so 5377 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5378 
    """
5379 
    Parameters:
5380 
     - skulist
5381 
     - timestamp
9816 kshitij.so 5382 
     - source
9776 vikram.rag 5383 
    """
9816 kshitij.so 5384 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5385 
    self.recv_updateMarketPlacePriceUpdateStatus()
5386 
 
9816 kshitij.so 5387 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5388 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5389 
    args = updateMarketPlacePriceUpdateStatus_args()
5390 
    args.skulist = skulist
5391 
    args.timestamp = timestamp
9816 kshitij.so 5392 
    args.source = source
9776 vikram.rag 5393 
    args.write(self._oprot)
5394 
    self._oprot.writeMessageEnd()
5395 
    self._oprot.trans.flush()
5396 
 
5397 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5399 
    if mtype == TMessageType.EXCEPTION:
5400 
      x = TApplicationException()
5401 
      x.read(self._iprot)
5402 
      self._iprot.readMessageEnd()
5403 
      raise x
5404 
    result = updateMarketPlacePriceUpdateStatus_result()
5405 
    result.read(self._iprot)
5406 
    self._iprot.readMessageEnd()
5407 
    return
5408 
 
5409 
 
5944 mandeep.dh 5410 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5411 
  def __init__(self, handler):
5412 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5413 
    self._processMap["addItem"] = Processor.process_addItem
5414 
    self._processMap["updateItem"] = Processor.process_updateItem
5415 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5416 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5417 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5418 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5419 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5420 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5421 
    self._processMap["getItem"] = Processor.process_getItem
5422 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5423 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5424 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5425 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5426 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5427 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5428 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5429 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5430 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5431 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5432 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5433 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5434 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5435 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5436 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5437 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5438 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5439 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5440 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5441 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5442 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5443 
    self._processMap["addCategory"] = Processor.process_addCategory
5444 
    self._processMap["getCategory"] = Processor.process_getCategory
5445 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5446 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5447 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5448 
    self._processMap["addTag"] = Processor.process_addTag
5449 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5450 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5451 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5452 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5453 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5454 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5455 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5456 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5457 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5458 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5459 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5460 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5461 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5462 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5463 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5464 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5465 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5466 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5467 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5468 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5469 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5470 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5471 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5472 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5473 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5474 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5475 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5476 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5477 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5478 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5479 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5480 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5481 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5482 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5483 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5484 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5485 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5486 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5487 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5488 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5489 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5490 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5491 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5492 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5493 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5494 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5495 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5496 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5497 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5498 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5499 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5500 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5501 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5502 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5503 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5504 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5505 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5506 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5507 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5508 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5509 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5510 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5511 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5512 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5513 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5514 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5515 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5516 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5517 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5518 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5519 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5520 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5521 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5522 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5523 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5524 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5525 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5526 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5527 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5528 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5529 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5530 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5531 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5532 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5533 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5534 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5535 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5536 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5537 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5538 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5539 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5540 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5541 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5542 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5543 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5544 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5545 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5546 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5547 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5548 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5549 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5550 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5551 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 5552 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 5553 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5554 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
5944 mandeep.dh 5555 
 
5556 
  def process(self, iprot, oprot):
5557 
    (name, type, seqid) = iprot.readMessageBegin()
5558 
    if name not in self._processMap:
5559 
      iprot.skip(TType.STRUCT)
5560 
      iprot.readMessageEnd()
5561 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5562 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5563 
      x.write(oprot)
5564 
      oprot.writeMessageEnd()
5565 
      oprot.trans.flush()
5566 
      return
5567 
    else:
5568 
      self._processMap[name](self, seqid, iprot, oprot)
5569 
    return True
5570 
 
5571 
  def process_addItem(self, seqid, iprot, oprot):
5572 
    args = addItem_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = addItem_result()
5576 
    try:
5577 
      result.success = self._handler.addItem(args.item)
5578 
    except CatalogServiceException, cex:
5579 
      result.cex = cex
5580 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
5585 
  def process_updateItem(self, seqid, iprot, oprot):
5586 
    args = updateItem_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = updateItem_result()
5590 
    try:
5591 
      result.success = self._handler.updateItem(args.item)
5592 
    except CatalogServiceException, cex:
5593 
      result.cex = cex
5594 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5595 
    result.write(oprot)
5596 
    oprot.writeMessageEnd()
5597 
    oprot.trans.flush()
5598 
 
5599 
  def process_isActive(self, seqid, iprot, oprot):
5600 
    args = isActive_args()
5601 
    args.read(iprot)
5602 
    iprot.readMessageEnd()
5603 
    result = isActive_result()
5604 
    try:
5605 
      result.success = self._handler.isActive(args.itemId)
5606 
    except CatalogServiceException, isex:
5607 
      result.isex = isex
5608 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5609 
    result.write(oprot)
5610 
    oprot.writeMessageEnd()
5611 
    oprot.trans.flush()
5612 
 
7438 amit.gupta 5613 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5614 
    args = getItemsStatus_args()
5615 
    args.read(iprot)
5616 
    iprot.readMessageEnd()
5617 
    result = getItemsStatus_result()
5618 
    try:
5619 
      result.success = self._handler.getItemsStatus(args.itemIds)
5620 
    except CatalogServiceException, isex:
5621 
      result.isex = isex
5622 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5623 
    result.write(oprot)
5624 
    oprot.writeMessageEnd()
5625 
    oprot.trans.flush()
5626 
 
5944 mandeep.dh 5627 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5628 
    args = getItemStatusDescription_args()
5629 
    args.read(iprot)
5630 
    iprot.readMessageEnd()
5631 
    result = getItemStatusDescription_result()
5632 
    try:
5633 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5634 
    except CatalogServiceException, isex:
5635 
      result.isex = isex
5636 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5637 
    result.write(oprot)
5638 
    oprot.writeMessageEnd()
5639 
    oprot.trans.flush()
5640 
 
5641 
  def process_startItemOn(self, seqid, iprot, oprot):
5642 
    args = startItemOn_args()
5643 
    args.read(iprot)
5644 
    iprot.readMessageEnd()
5645 
    result = startItemOn_result()
5646 
    try:
5647 
      self._handler.startItemOn(args.item_id, args.timestamp)
5648 
    except CatalogServiceException, cex:
5649 
      result.cex = cex
5650 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5651 
    result.write(oprot)
5652 
    oprot.writeMessageEnd()
5653 
    oprot.trans.flush()
5654 
 
5655 
  def process_retireItemOn(self, seqid, iprot, oprot):
5656 
    args = retireItemOn_args()
5657 
    args.read(iprot)
5658 
    iprot.readMessageEnd()
5659 
    result = retireItemOn_result()
5660 
    try:
5661 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5662 
    except CatalogServiceException, cex:
5663 
      result.cex = cex
5664 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5665 
    result.write(oprot)
5666 
    oprot.writeMessageEnd()
5667 
    oprot.trans.flush()
5668 
 
5669 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5670 
    args = changeItemStatus_args()
5671 
    args.read(iprot)
5672 
    iprot.readMessageEnd()
5673 
    result = changeItemStatus_result()
5674 
    try:
5675 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5676 
    except CatalogServiceException, cex:
5677 
      result.cex = cex
5678 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5679 
    result.write(oprot)
5680 
    oprot.writeMessageEnd()
5681 
    oprot.trans.flush()
5682 
 
5683 
  def process_getItem(self, seqid, iprot, oprot):
5684 
    args = getItem_args()
5685 
    args.read(iprot)
5686 
    iprot.readMessageEnd()
5687 
    result = getItem_result()
5688 
    try:
5689 
      result.success = self._handler.getItem(args.item_id)
5690 
    except CatalogServiceException, cex:
5691 
      result.cex = cex
5692 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5693 
    result.write(oprot)
5694 
    oprot.writeMessageEnd()
5695 
    oprot.trans.flush()
5696 
 
5697 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5698 
    args = getItemsByCatalogId_args()
5699 
    args.read(iprot)
5700 
    iprot.readMessageEnd()
5701 
    result = getItemsByCatalogId_result()
5702 
    try:
5703 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5704 
    except CatalogServiceException, cex:
5705 
      result.cex = cex
5706 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5707 
    result.write(oprot)
5708 
    oprot.writeMessageEnd()
5709 
    oprot.trans.flush()
5710 
 
5711 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5712 
    args = getValidItemsByCatalogId_args()
5713 
    args.read(iprot)
5714 
    iprot.readMessageEnd()
5715 
    result = getValidItemsByCatalogId_result()
5716 
    try:
5717 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5718 
    except CatalogServiceException, cex:
5719 
      result.cex = cex
5720 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5721 
    result.write(oprot)
5722 
    oprot.writeMessageEnd()
5723 
    oprot.trans.flush()
5724 
 
5725 
  def process_getAllItems(self, seqid, iprot, oprot):
5726 
    args = getAllItems_args()
5727 
    args.read(iprot)
5728 
    iprot.readMessageEnd()
5729 
    result = getAllItems_result()
5730 
    try:
5731 
      result.success = self._handler.getAllItems(args.isActive)
5732 
    except CatalogServiceException, cex:
5733 
      result.cex = cex
5734 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5735 
    result.write(oprot)
5736 
    oprot.writeMessageEnd()
5737 
    oprot.trans.flush()
5738 
 
5739 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5740 
    args = getAllItemsByStatus_args()
5741 
    args.read(iprot)
5742 
    iprot.readMessageEnd()
5743 
    result = getAllItemsByStatus_result()
5744 
    try:
5745 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5746 
    except CatalogServiceException, cex:
5747 
      result.cex = cex
5748 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5749 
    result.write(oprot)
5750 
    oprot.writeMessageEnd()
5751 
    oprot.trans.flush()
5752 
 
5753 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5754 
    args = markItemAsContentComplete_args()
5755 
    args.read(iprot)
5756 
    iprot.readMessageEnd()
5757 
    result = markItemAsContentComplete_result()
5758 
    try:
9253 rajveer 5759 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5760 
    except CatalogServiceException, cex:
5761 
      result.cex = cex
5762 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5763 
    result.write(oprot)
5764 
    oprot.writeMessageEnd()
5765 
    oprot.trans.flush()
5766 
 
5767 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5768 
    args = getAllItemsInRange_args()
5769 
    args.read(iprot)
5770 
    iprot.readMessageEnd()
5771 
    result = getAllItemsInRange_result()
5772 
    try:
5773 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5774 
    except CatalogServiceException, cex:
5775 
      result.cex = cex
5776 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5777 
    result.write(oprot)
5778 
    oprot.writeMessageEnd()
5779 
    oprot.trans.flush()
5780 
 
5781 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5782 
    args = getAllItemsByStatusInRange_args()
5783 
    args.read(iprot)
5784 
    iprot.readMessageEnd()
5785 
    result = getAllItemsByStatusInRange_result()
5786 
    try:
5787 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5788 
    except CatalogServiceException, cex:
5789 
      result.cex = cex
5790 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5791 
    result.write(oprot)
5792 
    oprot.writeMessageEnd()
5793 
    oprot.trans.flush()
5794 
 
5795 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5796 
    args = getItemCountByStatus_args()
5797 
    args.read(iprot)
5798 
    iprot.readMessageEnd()
5799 
    result = getItemCountByStatus_result()
5800 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5801 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5802 
    result.write(oprot)
5803 
    oprot.writeMessageEnd()
5804 
    oprot.trans.flush()
5805 
 
5806 
  def process_getBestSellers(self, seqid, iprot, oprot):
5807 
    args = getBestSellers_args()
5808 
    args.read(iprot)
5809 
    iprot.readMessageEnd()
5810 
    result = getBestSellers_result()
5811 
    try:
5812 
      result.success = self._handler.getBestSellers()
5813 
    except CatalogServiceException, isex:
5814 
      result.isex = isex
5815 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
5819 
 
5820 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5821 
    args = getBestSellersCatalogIds_args()
5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
5824 
    result = getBestSellersCatalogIds_result()
5825 
    try:
5826 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5827 
    except CatalogServiceException, cex:
5828 
      result.cex = cex
5829 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
5834 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5835 
    args = getBestSellersCount_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = getBestSellersCount_result()
5839 
    try:
5840 
      result.success = self._handler.getBestSellersCount()
5841 
    except CatalogServiceException, cex:
5842 
      result.cex = cex
5843 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
5847 
 
5848 
  def process_getBestDeals(self, seqid, iprot, oprot):
5849 
    args = getBestDeals_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = getBestDeals_result()
5853 
    try:
5854 
      result.success = self._handler.getBestDeals()
5855 
    except CatalogServiceException, isex:
5856 
      result.isex = isex
5857 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
5862 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5863 
    args = getBestDealsCatalogIds_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = getBestDealsCatalogIds_result()
5867 
    try:
5868 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5869 
    except CatalogServiceException, cex:
5870 
      result.cex = cex
5871 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
5875 
 
5876 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5877 
    args = getBestDealsCount_args()
5878 
    args.read(iprot)
5879 
    iprot.readMessageEnd()
5880 
    result = getBestDealsCount_result()
5881 
    try:
5882 
      result.success = self._handler.getBestDealsCount()
5883 
    except CatalogServiceException, cex:
5884 
      result.cex = cex
5885 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5886 
    result.write(oprot)
5887 
    oprot.writeMessageEnd()
5888 
    oprot.trans.flush()
5889 
 
5890 
  def process_getComingSoon(self, seqid, iprot, oprot):
5891 
    args = getComingSoon_args()
5892 
    args.read(iprot)
5893 
    iprot.readMessageEnd()
5894 
    result = getComingSoon_result()
5895 
    try:
5896 
      result.success = self._handler.getComingSoon()
5897 
    except CatalogServiceException, isex:
5898 
      result.isex = isex
5899 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5900 
    result.write(oprot)
5901 
    oprot.writeMessageEnd()
5902 
    oprot.trans.flush()
5903 
 
5904 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5905 
    args = getComingSoonCatalogIds_args()
5906 
    args.read(iprot)
5907 
    iprot.readMessageEnd()
5908 
    result = getComingSoonCatalogIds_result()
5909 
    try:
5910 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5911 
    except CatalogServiceException, cex:
5912 
      result.cex = cex
5913 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5914 
    result.write(oprot)
5915 
    oprot.writeMessageEnd()
5916 
    oprot.trans.flush()
5917 
 
5918 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5919 
    args = getComingSoonCount_args()
5920 
    args.read(iprot)
5921 
    iprot.readMessageEnd()
5922 
    result = getComingSoonCount_result()
5923 
    try:
5924 
      result.success = self._handler.getComingSoonCount()
5925 
    except CatalogServiceException, cex:
5926 
      result.cex = cex
5927 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5928 
    result.write(oprot)
5929 
    oprot.writeMessageEnd()
5930 
    oprot.trans.flush()
5931 
 
5932 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5933 
    args = getLatestArrivals_args()
5934 
    args.read(iprot)
5935 
    iprot.readMessageEnd()
5936 
    result = getLatestArrivals_result()
5937 
    try:
5938 
      result.success = self._handler.getLatestArrivals()
5939 
    except CatalogServiceException, isex:
5940 
      result.isex = isex
5941 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5942 
    result.write(oprot)
5943 
    oprot.writeMessageEnd()
5944 
    oprot.trans.flush()
5945 
 
5946 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5947 
    args = getLatestArrivalsCatalogIds_args()
5948 
    args.read(iprot)
5949 
    iprot.readMessageEnd()
5950 
    result = getLatestArrivalsCatalogIds_result()
5951 
    try:
5952 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5953 
    except CatalogServiceException, cex:
5954 
      result.cex = cex
5955 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5956 
    result.write(oprot)
5957 
    oprot.writeMessageEnd()
5958 
    oprot.trans.flush()
5959 
 
5960 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5961 
    args = getLatestArrivalsCount_args()
5962 
    args.read(iprot)
5963 
    iprot.readMessageEnd()
5964 
    result = getLatestArrivalsCount_result()
5965 
    try:
5966 
      result.success = self._handler.getLatestArrivalsCount()
5967 
    except CatalogServiceException, cex:
5968 
      result.cex = cex
5969 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
5973 
 
5974 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5975 
    args = generateNewEntityID_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = generateNewEntityID_result()
5979 
    result.success = self._handler.generateNewEntityID()
5980 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5981 
    result.write(oprot)
5982 
    oprot.writeMessageEnd()
5983 
    oprot.trans.flush()
5984 
 
5985 
  def process_addCategory(self, seqid, iprot, oprot):
5986 
    args = addCategory_args()
5987 
    args.read(iprot)
5988 
    iprot.readMessageEnd()
5989 
    result = addCategory_result()
5990 
    result.success = self._handler.addCategory(args.category)
5991 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5992 
    result.write(oprot)
5993 
    oprot.writeMessageEnd()
5994 
    oprot.trans.flush()
5995 
 
5996 
  def process_getCategory(self, seqid, iprot, oprot):
5997 
    args = getCategory_args()
5998 
    args.read(iprot)
5999 
    iprot.readMessageEnd()
6000 
    result = getCategory_result()
6001 
    result.success = self._handler.getCategory(args.id)
6002 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6003 
    result.write(oprot)
6004 
    oprot.writeMessageEnd()
6005 
    oprot.trans.flush()
6006 
 
6007 
  def process_getAllCategories(self, seqid, iprot, oprot):
6008 
    args = getAllCategories_args()
6009 
    args.read(iprot)
6010 
    iprot.readMessageEnd()
6011 
    result = getAllCategories_result()
6012 
    result.success = self._handler.getAllCategories()
6013 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6014 
    result.write(oprot)
6015 
    oprot.writeMessageEnd()
6016 
    oprot.trans.flush()
6017 
 
6018 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6019 
    args = getAllSimilarItems_args()
6020 
    args.read(iprot)
6021 
    iprot.readMessageEnd()
6022 
    result = getAllSimilarItems_result()
6023 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6024 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6025 
    result.write(oprot)
6026 
    oprot.writeMessageEnd()
6027 
    oprot.trans.flush()
6028 
 
6029 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6030 
    args = addSimilarItem_args()
6031 
    args.read(iprot)
6032 
    iprot.readMessageEnd()
6033 
    result = addSimilarItem_result()
6034 
    try:
6035 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6036 
    except CatalogServiceException, cex:
6037 
      result.cex = cex
6038 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6039 
    result.write(oprot)
6040 
    oprot.writeMessageEnd()
6041 
    oprot.trans.flush()
6042 
 
6512 kshitij.so 6043 
  def process_addTag(self, seqid, iprot, oprot):
6044 
    args = addTag_args()
6045 
    args.read(iprot)
6046 
    iprot.readMessageEnd()
6047 
    result = addTag_result()
6048 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6049 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6050 
    result.write(oprot)
6051 
    oprot.writeMessageEnd()
6052 
    oprot.trans.flush()
6053 
 
6054 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6055 
    args = deleteEntityTag_args()
6056 
    args.read(iprot)
6057 
    iprot.readMessageEnd()
6058 
    result = deleteEntityTag_result()
6059 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6060 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6061 
    result.write(oprot)
6062 
    oprot.writeMessageEnd()
6063 
    oprot.trans.flush()
6064 
 
6065 
  def process_deleteTag(self, seqid, iprot, oprot):
6066 
    args = deleteTag_args()
6067 
    args.read(iprot)
6068 
    iprot.readMessageEnd()
6069 
    result = deleteTag_result()
6070 
    result.success = self._handler.deleteTag(args.displayName)
6071 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6072 
    result.write(oprot)
6073 
    oprot.writeMessageEnd()
6074 
    oprot.trans.flush()
6075 
 
6076 
  def process_getAllTags(self, seqid, iprot, oprot):
6077 
    args = getAllTags_args()
6078 
    args.read(iprot)
6079 
    iprot.readMessageEnd()
6080 
    result = getAllTags_result()
6081 
    result.success = self._handler.getAllTags()
6082 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6083 
    result.write(oprot)
6084 
    oprot.writeMessageEnd()
6085 
    oprot.trans.flush()
6086 
 
6087 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6088 
    args = getAllEntitiesByTagName_args()
6089 
    args.read(iprot)
6090 
    iprot.readMessageEnd()
6091 
    result = getAllEntitiesByTagName_result()
6092 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6093 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6094 
    result.write(oprot)
6095 
    oprot.writeMessageEnd()
6096 
    oprot.trans.flush()
6097 
 
6845 amit.gupta 6098 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6099 
    args = getAllEntityTags_args()
6100 
    args.read(iprot)
6101 
    iprot.readMessageEnd()
6102 
    result = getAllEntityTags_result()
6103 
    result.success = self._handler.getAllEntityTags()
6104 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6105 
    result.write(oprot)
6106 
    oprot.writeMessageEnd()
6107 
    oprot.trans.flush()
6108 
 
6850 kshitij.so 6109 
  def process_addBanner(self, seqid, iprot, oprot):
6110 
    args = addBanner_args()
6111 
    args.read(iprot)
6112 
    iprot.readMessageEnd()
6113 
    result = addBanner_result()
8590 kshitij.so 6114 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6115 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6116 
    result.write(oprot)
6117 
    oprot.writeMessageEnd()
6118 
    oprot.trans.flush()
6119 
 
8579 kshitij.so 6120 
  def process_updateBanner(self, seqid, iprot, oprot):
6121 
    args = updateBanner_args()
6122 
    args.read(iprot)
6123 
    iprot.readMessageEnd()
6124 
    result = updateBanner_result()
6125 
    result.success = self._handler.updateBanner(args.banner)
6126 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6127 
    result.write(oprot)
6128 
    oprot.writeMessageEnd()
6129 
    oprot.trans.flush()
6130 
 
6850 kshitij.so 6131 
  def process_getAllBanners(self, seqid, iprot, oprot):
6132 
    args = getAllBanners_args()
6133 
    args.read(iprot)
6134 
    iprot.readMessageEnd()
6135 
    result = getAllBanners_result()
6136 
    result.success = self._handler.getAllBanners()
6137 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6138 
    result.write(oprot)
6139 
    oprot.writeMessageEnd()
6140 
    oprot.trans.flush()
6141 
 
6142 
  def process_deleteBanner(self, seqid, iprot, oprot):
6143 
    args = deleteBanner_args()
6144 
    args.read(iprot)
6145 
    iprot.readMessageEnd()
6146 
    result = deleteBanner_result()
9155 kshitij.so 6147 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6148 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6149 
    result.write(oprot)
6150 
    oprot.writeMessageEnd()
6151 
    oprot.trans.flush()
6152 
 
6153 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6154 
    args = getBannerDetails_args()
6155 
    args.read(iprot)
6156 
    iprot.readMessageEnd()
6157 
    result = getBannerDetails_result()
9155 kshitij.so 6158 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6159 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6160 
    result.write(oprot)
6161 
    oprot.writeMessageEnd()
6162 
    oprot.trans.flush()
6163 
 
6164 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6165 
    args = getActiveBanners_args()
6166 
    args.read(iprot)
6167 
    iprot.readMessageEnd()
6168 
    result = getActiveBanners_result()
6169 
    result.success = self._handler.getActiveBanners()
6170 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
6849 kshitij.so 6175 
  def process_addBannerMap(self, seqid, iprot, oprot):
6176 
    args = addBannerMap_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = addBannerMap_result()
8579 kshitij.so 6180 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6181 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6182 
    result.write(oprot)
6183 
    oprot.writeMessageEnd()
6184 
    oprot.trans.flush()
6185 
 
8579 kshitij.so 6186 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6187 
    args = updateBannerMap_args()
6188 
    args.read(iprot)
6189 
    iprot.readMessageEnd()
6190 
    result = updateBannerMap_result()
6191 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6192 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
6196 
 
6849 kshitij.so 6197 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6198 
    args = deleteBannerMap_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = deleteBannerMap_result()
6202 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6203 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6204 
    result.write(oprot)
6205 
    oprot.writeMessageEnd()
6206 
    oprot.trans.flush()
6207 
 
6208 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6209 
    args = getBannerMapDetails_args()
6210 
    args.read(iprot)
6211 
    iprot.readMessageEnd()
6212 
    result = getBannerMapDetails_result()
9155 kshitij.so 6213 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6214 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6215 
    result.write(oprot)
6216 
    oprot.writeMessageEnd()
6217 
    oprot.trans.flush()
6218 
 
8579 kshitij.so 6219 
  def process_addBannerUri(self, seqid, iprot, oprot):
6220 
    args = addBannerUri_args()
6221 
    args.read(iprot)
6222 
    iprot.readMessageEnd()
6223 
    result = addBannerUri_result()
6224 
    self._handler.addBannerUri(args.bannerUriMappings)
6225 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6226 
    result.write(oprot)
6227 
    oprot.writeMessageEnd()
6228 
    oprot.trans.flush()
6229 
 
6230 
  def process_getUriMapping(self, seqid, iprot, oprot):
6231 
    args = getUriMapping_args()
6232 
    args.read(iprot)
6233 
    iprot.readMessageEnd()
6234 
    result = getUriMapping_result()
9155 kshitij.so 6235 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6236 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6237 
    result.write(oprot)
6238 
    oprot.writeMessageEnd()
6239 
    oprot.trans.flush()
6240 
 
6241 
  def process_addCampaign(self, seqid, iprot, oprot):
6242 
    args = addCampaign_args()
6243 
    args.read(iprot)
6244 
    iprot.readMessageEnd()
6245 
    result = addCampaign_result()
6246 
    self._handler.addCampaign(args.campaign)
6247 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6248 
    result.write(oprot)
6249 
    oprot.writeMessageEnd()
6250 
    oprot.trans.flush()
6251 
 
6252 
  def process_getCampaigns(self, seqid, iprot, oprot):
6253 
    args = getCampaigns_args()
6254 
    args.read(iprot)
6255 
    iprot.readMessageEnd()
6256 
    result = getCampaigns_result()
6257 
    result.success = self._handler.getCampaigns(args.campaignName)
6258 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6259 
    result.write(oprot)
6260 
    oprot.writeMessageEnd()
6261 
    oprot.trans.flush()
6262 
 
6263 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6264 
    args = deleteCampaign_args()
6265 
    args.read(iprot)
6266 
    iprot.readMessageEnd()
6267 
    result = deleteCampaign_result()
6268 
    self._handler.deleteCampaign(args.campaignId)
6269 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6270 
    result.write(oprot)
6271 
    oprot.writeMessageEnd()
6272 
    oprot.trans.flush()
6273 
 
6274 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6275 
    args = getAllCampaigns_args()
6276 
    args.read(iprot)
6277 
    iprot.readMessageEnd()
6278 
    result = getAllCampaigns_result()
6279 
    result.success = self._handler.getAllCampaigns()
6280 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6281 
    result.write(oprot)
6282 
    oprot.writeMessageEnd()
6283 
    oprot.trans.flush()
6284 
 
9155 kshitij.so 6285 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6286 
    args = getActiveBannersForMobileSite_args()
6287 
    args.read(iprot)
6288 
    iprot.readMessageEnd()
6289 
    result = getActiveBannersForMobileSite_result()
6290 
    result.success = self._handler.getActiveBannersForMobileSite()
6291 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6292 
    result.write(oprot)
6293 
    oprot.writeMessageEnd()
6294 
    oprot.trans.flush()
6295 
 
5944 mandeep.dh 6296 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6297 
    args = deleteSimilarItem_args()
6298 
    args.read(iprot)
6299 
    iprot.readMessageEnd()
6300 
    result = deleteSimilarItem_result()
6301 
    try:
6302 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6303 
    except CatalogServiceException, cex:
6304 
      result.cex = cex
6305 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6306 
    result.write(oprot)
6307 
    oprot.writeMessageEnd()
6308 
    oprot.trans.flush()
6309 
 
6310 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6311 
    args = checkSimilarItem_args()
6312 
    args.read(iprot)
6313 
    iprot.readMessageEnd()
6314 
    result = checkSimilarItem_result()
6315 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6316 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
6320 
 
6321 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6322 
    args = validateRiskyStatus_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = validateRiskyStatus_result()
6326 
    self._handler.validateRiskyStatus(args.itemId)
6327 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6328 
    result.write(oprot)
6329 
    oprot.writeMessageEnd()
6330 
    oprot.trans.flush()
6331 
 
6332 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6333 
    args = changeItemRiskyFlag_args()
6334 
    args.read(iprot)
6335 
    iprot.readMessageEnd()
6336 
    result = changeItemRiskyFlag_result()
6337 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6338 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
6342 
 
6343 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6344 
    args = getItemsByRiskyFlag_args()
6345 
    args.read(iprot)
6346 
    iprot.readMessageEnd()
6347 
    result = getItemsByRiskyFlag_result()
6348 
    result.success = self._handler.getItemsByRiskyFlag()
6349 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6350 
    result.write(oprot)
6351 
    oprot.writeMessageEnd()
6352 
    oprot.trans.flush()
6353 
 
6354 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6355 
    args = getItemsForMasterSheet_args()
6356 
    args.read(iprot)
6357 
    iprot.readMessageEnd()
6358 
    result = getItemsForMasterSheet_result()
6359 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6360 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6361 
    result.write(oprot)
6362 
    oprot.writeMessageEnd()
6363 
    oprot.trans.flush()
6364 
 
6365 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6366 
    args = getSimilarItemsCatalogIds_args()
6367 
    args.read(iprot)
6368 
    iprot.readMessageEnd()
6369 
    result = getSimilarItemsCatalogIds_result()
6370 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6371 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6372 
    result.write(oprot)
6373 
    oprot.writeMessageEnd()
6374 
    oprot.trans.flush()
6375 
 
6376 
  def process_addProductNotification(self, seqid, iprot, oprot):
6377 
    args = addProductNotification_args()
6378 
    args.read(iprot)
6379 
    iprot.readMessageEnd()
6380 
    result = addProductNotification_result()
6381 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6382 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
6386 
 
6387 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6388 
    args = sendProductNotifications_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = sendProductNotifications_result()
6392 
    result.success = self._handler.sendProductNotifications()
6393 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6394 
    result.write(oprot)
6395 
    oprot.writeMessageEnd()
6396 
    oprot.trans.flush()
6397 
 
6398 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6399 
    args = getAllBrandsByCategory_args()
6400 
    args.read(iprot)
6401 
    iprot.readMessageEnd()
6402 
    result = getAllBrandsByCategory_result()
6403 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6404 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6405 
    result.write(oprot)
6406 
    oprot.writeMessageEnd()
6407 
    oprot.trans.flush()
6408 
 
6409 
  def process_getAllBrands(self, seqid, iprot, oprot):
6410 
    args = getAllBrands_args()
6411 
    args.read(iprot)
6412 
    iprot.readMessageEnd()
6413 
    result = getAllBrands_result()
6414 
    result.success = self._handler.getAllBrands()
6415 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6416 
    result.write(oprot)
6417 
    oprot.writeMessageEnd()
6418 
    oprot.trans.flush()
6419 
 
6420 
  def process_getAllSources(self, seqid, iprot, oprot):
6421 
    args = getAllSources_args()
6422 
    args.read(iprot)
6423 
    iprot.readMessageEnd()
6424 
    result = getAllSources_result()
6425 
    result.success = self._handler.getAllSources()
6426 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6427 
    result.write(oprot)
6428 
    oprot.writeMessageEnd()
6429 
    oprot.trans.flush()
6430 
 
6431 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6432 
    args = getItemPricingBySource_args()
6433 
    args.read(iprot)
6434 
    iprot.readMessageEnd()
6435 
    result = getItemPricingBySource_result()
6436 
    try:
6437 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6438 
    except CatalogServiceException, cex:
6439 
      result.cex = cex
6440 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6441 
    result.write(oprot)
6442 
    oprot.writeMessageEnd()
6443 
    oprot.trans.flush()
6444 
 
6445 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6446 
    args = addSourceItemPricing_args()
6447 
    args.read(iprot)
6448 
    iprot.readMessageEnd()
6449 
    result = addSourceItemPricing_result()
6450 
    try:
6451 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6452 
    except CatalogServiceException, cex:
6453 
      result.cex = cex
6454 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6455 
    result.write(oprot)
6456 
    oprot.writeMessageEnd()
6457 
    oprot.trans.flush()
6458 
 
6459 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6460 
    args = getAllSourcePricing_args()
6461 
    args.read(iprot)
6462 
    iprot.readMessageEnd()
6463 
    result = getAllSourcePricing_result()
6464 
    try:
6465 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6466 
    except CatalogServiceException, cex:
6467 
      result.cex = cex
6468 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6469 
    result.write(oprot)
6470 
    oprot.writeMessageEnd()
6471 
    oprot.trans.flush()
6472 
 
6473 
  def process_getItemForSource(self, seqid, iprot, oprot):
6474 
    args = getItemForSource_args()
6475 
    args.read(iprot)
6476 
    iprot.readMessageEnd()
6477 
    result = getItemForSource_result()
6478 
    try:
6479 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6480 
    except CatalogServiceException, cex:
6481 
      result.cex = cex
6482 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6483 
    result.write(oprot)
6484 
    oprot.writeMessageEnd()
6485 
    oprot.trans.flush()
6486 
 
6487 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6488 
    args = searchItemsInRange_args()
6489 
    args.read(iprot)
6490 
    iprot.readMessageEnd()
6491 
    result = searchItemsInRange_result()
6492 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6493 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6494 
    result.write(oprot)
6495 
    oprot.writeMessageEnd()
6496 
    oprot.trans.flush()
6497 
 
6498 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6499 
    args = getSearchResultCount_args()
6500 
    args.read(iprot)
6501 
    iprot.readMessageEnd()
6502 
    result = getSearchResultCount_result()
6503 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6504 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
6509 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6510 
    args = getProductNotifications_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = getProductNotifications_result()
6514 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6515 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6516 
    result.write(oprot)
6517 
    oprot.writeMessageEnd()
6518 
    oprot.trans.flush()
6519 
 
6520 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6521 
    args = getProductNotificationRequestCount_args()
6522 
    args.read(iprot)
6523 
    iprot.readMessageEnd()
6524 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6525 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6526 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6527 
    result.write(oprot)
6528 
    oprot.writeMessageEnd()
6529 
    oprot.trans.flush()
6530 
 
6531 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6532 
    args = addAuthorizationLog_args()
6533 
    args.read(iprot)
6534 
    iprot.readMessageEnd()
6535 
    result = addAuthorizationLog_result()
6536 
    try:
6537 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6538 
    except CatalogServiceException, cex:
6539 
      result.cex = cex
6540 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6541 
    result.write(oprot)
6542 
    oprot.writeMessageEnd()
6543 
    oprot.trans.flush()
6544 
 
6545 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6546 
    args = addupdateVoucherForItem_args()
6547 
    args.read(iprot)
6548 
    iprot.readMessageEnd()
6549 
    result = addupdateVoucherForItem_result()
6550 
    try:
6551 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6552 
    except CatalogServiceException, cex:
6553 
      result.cex = cex
6554 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6555 
    result.write(oprot)
6556 
    oprot.writeMessageEnd()
6557 
    oprot.trans.flush()
6558 
 
6559 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6560 
    args = deleteVoucherForItem_args()
6561 
    args.read(iprot)
6562 
    iprot.readMessageEnd()
6563 
    result = deleteVoucherForItem_result()
6564 
    try:
6565 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6566 
    except CatalogServiceException, cex:
6567 
      result.cex = cex
6568 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6569 
    result.write(oprot)
6570 
    oprot.writeMessageEnd()
6571 
    oprot.trans.flush()
6572 
 
6573 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6574 
    args = getVoucherAmount_args()
6575 
    args.read(iprot)
6576 
    iprot.readMessageEnd()
6577 
    result = getVoucherAmount_result()
6578 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6579 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6580 
    result.write(oprot)
6581 
    oprot.writeMessageEnd()
6582 
    oprot.trans.flush()
6583 
 
6584 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6585 
    args = getAllItemVouchers_args()
6586 
    args.read(iprot)
6587 
    iprot.readMessageEnd()
6588 
    result = getAllItemVouchers_result()
6589 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6590 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6591 
    result.write(oprot)
6592 
    oprot.writeMessageEnd()
6593 
    oprot.trans.flush()
6594 
 
6595 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6596 
    args = isValidCatalogItemId_args()
6597 
    args.read(iprot)
6598 
    iprot.readMessageEnd()
6599 
    result = isValidCatalogItemId_result()
6600 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6601 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6602 
    result.write(oprot)
6603 
    oprot.writeMessageEnd()
6604 
    oprot.trans.flush()
6605 
 
6039 amit.gupta 6606 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6607 
    args = getVatPercentageForItem_args()
6608 
    args.read(iprot)
6609 
    iprot.readMessageEnd()
6610 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6611 
    try:
6612 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6613 
    except CatalogServiceException, cex:
6614 
      result.cex = cex
6039 amit.gupta 6615 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
5944 mandeep.dh 6619 
 
6039 amit.gupta 6620 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6621 
    args = getVatAmountForItem_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = getVatAmountForItem_result()
6625 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6626 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6531 vikram.rag 6631 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6632 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6636 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6637 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6039 amit.gupta 6641 
 
6821 amar.kumar 6642 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6643 
    args = getAllAliveItems_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = getAllAliveItems_result()
6647 
    result.success = self._handler.getAllAliveItems()
6648 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6649 
    result.write(oprot)
6650 
    oprot.writeMessageEnd()
6651 
    oprot.trans.flush()
6652 
 
6805 anupam.sin 6653 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6654 
    args = getInsuranceAmount_args()
6655 
    args.read(iprot)
6656 
    iprot.readMessageEnd()
6657 
    result = getInsuranceAmount_result()
6921 anupam.sin 6658 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6659 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6660 
    result.write(oprot)
6661 
    oprot.writeMessageEnd()
6662 
    oprot.trans.flush()
6531 vikram.rag 6663 
 
6805 anupam.sin 6664 
  def process_getInsurer(self, seqid, iprot, oprot):
6665 
    args = getInsurer_args()
6666 
    args.read(iprot)
6667 
    iprot.readMessageEnd()
6668 
    result = getInsurer_result()
6669 
    result.success = self._handler.getInsurer(args.insurerId)
6670 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
6838 vikram.rag 6675 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6676 
    args = getAllInsurers_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = getAllInsurers_result()
6680 
    result.success = self._handler.getAllInsurers()
6681 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6805 anupam.sin 6685 
 
6962 rajveer 6686 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6687 
    args = updateInsuranceDeclaredAmount_args()
6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
6690 
    result = updateInsuranceDeclaredAmount_result()
6691 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6692 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6693 
    result.write(oprot)
6694 
    oprot.writeMessageEnd()
6695 
    oprot.trans.flush()
6838 vikram.rag 6696 
 
7190 amar.kumar 6697 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6698 
    args = getFreebieForItem_args()
6699 
    args.read(iprot)
6700 
    iprot.readMessageEnd()
6701 
    result = getFreebieForItem_result()
6702 
    result.success = self._handler.getFreebieForItem(args.itemId)
6703 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6704 
    result.write(oprot)
6705 
    oprot.writeMessageEnd()
6706 
    oprot.trans.flush()
6962 rajveer 6707 
 
7190 amar.kumar 6708 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6709 
    args = addOrUpdateFreebieForItem_args()
6710 
    args.read(iprot)
6711 
    iprot.readMessageEnd()
6712 
    result = addOrUpdateFreebieForItem_result()
6713 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6714 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
6718 
 
7272 amit.gupta 6719 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6720 
    args = addOrUpdateBrandInfo_args()
6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
6723 
    result = addOrUpdateBrandInfo_result()
6724 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6725 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
6730 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6731 
    args = getBrandInfo_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getBrandInfo_result()
6735 
    result.success = self._handler.getBrandInfo()
6736 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
6740 
 
7256 rajveer 6741 
  def process_getStorePricing(self, seqid, iprot, oprot):
6742 
    args = getStorePricing_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = getStorePricing_result()
6746 
    result.success = self._handler.getStorePricing(args.itemId)
6747 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
7190 amar.kumar 6751 
 
7306 rajveer 6752 
  def process_getStorePricings(self, seqid, iprot, oprot):
6753 
    args = getStorePricings_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = getStorePricings_result()
6757 
    result.success = self._handler.getStorePricings(args.itemIds)
6758 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6759 
    result.write(oprot)
6760 
    oprot.writeMessageEnd()
6761 
    oprot.trans.flush()
6762 
 
7265 rajveer 6763 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6764 
    args = updateStorePricing_args()
6765 
    args.read(iprot)
6766 
    iprot.readMessageEnd()
6767 
    result = updateStorePricing_result()
7382 rajveer 6768 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6769 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
7256 rajveer 6773 
 
7281 kshitij.so 6774 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6775 
    args = getAllAmazonListedItems_args()
6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
6778 
    result = getAllAmazonListedItems_result()
6779 
    result.success = self._handler.getAllAmazonListedItems()
6780 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
7265 rajveer 6784 
 
8619 kshitij.so 6785 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6786 
    args = searchAmazonItems_args()
6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
6789 
    result = searchAmazonItems_result()
6790 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6791 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6792 
    result.write(oprot)
6793 
    oprot.writeMessageEnd()
6794 
    oprot.trans.flush()
6795 
 
6796 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6797 
    args = getAmazonSearchResultCount_args()
6798 
    args.read(iprot)
6799 
    iprot.readMessageEnd()
6800 
    result = getAmazonSearchResultCount_result()
6801 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6802 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6803 
    result.write(oprot)
6804 
    oprot.writeMessageEnd()
6805 
    oprot.trans.flush()
6806 
 
6807 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6808 
    args = getCountForAmazonlistedItems_args()
6809 
    args.read(iprot)
6810 
    iprot.readMessageEnd()
6811 
    result = getCountForAmazonlistedItems_result()
6812 
    result.success = self._handler.getCountForAmazonlistedItems()
6813 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6814 
    result.write(oprot)
6815 
    oprot.writeMessageEnd()
6816 
    oprot.trans.flush()
6817 
 
7281 kshitij.so 6818 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6819 
    args = getAmazonItemDetails_args()
6820 
    args.read(iprot)
6821 
    iprot.readMessageEnd()
6822 
    result = getAmazonItemDetails_result()
6823 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6824 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6825 
    result.write(oprot)
6826 
    oprot.writeMessageEnd()
6827 
    oprot.trans.flush()
6828 
 
6829 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6830 
    args = updateAmazonItemDetails_args()
6831 
    args.read(iprot)
6832 
    iprot.readMessageEnd()
6833 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6834 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6835 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6836 
    result.write(oprot)
6837 
    oprot.writeMessageEnd()
6838 
    oprot.trans.flush()
6839 
 
6840 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6841 
    args = addAmazonItem_args()
6842 
    args.read(iprot)
6843 
    iprot.readMessageEnd()
6844 
    result = addAmazonItem_result()
6845 
    self._handler.addAmazonItem(args.amazonlisted)
6846 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6847 
    result.write(oprot)
6848 
    oprot.writeMessageEnd()
6849 
    oprot.trans.flush()
6850 
 
7291 vikram.rag 6851 
  def process_getAsinItems(self, seqid, iprot, oprot):
6852 
    args = getAsinItems_args()
6853 
    args.read(iprot)
6854 
    iprot.readMessageEnd()
6855 
    result = getAsinItems_result()
6856 
    result.success = self._handler.getAsinItems()
6857 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6858 
    result.write(oprot)
6859 
    oprot.writeMessageEnd()
6860 
    oprot.trans.flush()
7281 kshitij.so 6861 
 
7291 vikram.rag 6862 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6863 
    args = getAllFbaListedItems_args()
6864 
    args.read(iprot)
6865 
    iprot.readMessageEnd()
6866 
    result = getAllFbaListedItems_result()
6867 
    result.success = self._handler.getAllFbaListedItems()
6868 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6869 
    result.write(oprot)
6870 
    oprot.writeMessageEnd()
6871 
    oprot.trans.flush()
6872 
 
6873 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6874 
    args = getAllNonFbaListedItems_args()
6875 
    args.read(iprot)
6876 
    iprot.readMessageEnd()
6877 
    result = getAllNonFbaListedItems_result()
6878 
    result.success = self._handler.getAllNonFbaListedItems()
6879 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6880 
    result.write(oprot)
6881 
    oprot.writeMessageEnd()
6882 
    oprot.trans.flush()
6883 
 
7460 kshitij.so 6884 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6885 
    args = updateItemInventory_args()
6886 
    args.read(iprot)
6887 
    iprot.readMessageEnd()
6888 
    result = updateItemInventory_result()
6889 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6890 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6891 
    result.write(oprot)
6892 
    oprot.writeMessageEnd()
6893 
    oprot.trans.flush()
7291 vikram.rag 6894 
 
7770 kshitij.so 6895 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6896 
    args = updateTimestampForAmazonFeeds_args()
6897 
    args.read(iprot)
6898 
    iprot.readMessageEnd()
6899 
    result = updateTimestampForAmazonFeeds_result()
6900 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6901 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6902 
    result.write(oprot)
6903 
    oprot.writeMessageEnd()
6904 
    oprot.trans.flush()
7460 kshitij.so 6905 
 
7897 amar.kumar 6906 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6907 
    args = getAllParentCategories_args()
6908 
    args.read(iprot)
6909 
    iprot.readMessageEnd()
6910 
    result = getAllParentCategories_result()
6911 
    result.success = self._handler.getAllParentCategories()
6912 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6913 
    result.write(oprot)
6914 
    oprot.writeMessageEnd()
6915 
    oprot.trans.flush()
7770 kshitij.so 6916 
 
7977 kshitij.so 6917 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6918 
    args = addPageViewEvent_args()
6919 
    args.read(iprot)
6920 
    iprot.readMessageEnd()
6921 
    result = addPageViewEvent_result()
6922 
    self._handler.addPageViewEvent(args.pageViewEvents)
6923 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6924 
    result.write(oprot)
6925 
    oprot.writeMessageEnd()
6926 
    oprot.trans.flush()
7897 amar.kumar 6927 
 
7977 kshitij.so 6928 
  def process_addCartEvent(self, seqid, iprot, oprot):
6929 
    args = addCartEvent_args()
6930 
    args.read(iprot)
6931 
    iprot.readMessageEnd()
6932 
    result = addCartEvent_result()
6933 
    self._handler.addCartEvent(args.cartEvents)
6934 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
6938 
 
8182 amar.kumar 6939 
  def process_addEbayItem(self, seqid, iprot, oprot):
6940 
    args = addEbayItem_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = addEbayItem_result()
6944 
    self._handler.addEbayItem(args.ebayItem)
6945 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6946 
    result.write(oprot)
6947 
    oprot.writeMessageEnd()
6948 
    oprot.trans.flush()
6949 
 
6950 
  def process_getEbayItem(self, seqid, iprot, oprot):
6951 
    args = getEbayItem_args()
6952 
    args.read(iprot)
6953 
    iprot.readMessageEnd()
6954 
    result = getEbayItem_result()
6955 
    result.success = self._handler.getEbayItem(args.listingId)
6956 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6957 
    result.write(oprot)
6958 
    oprot.writeMessageEnd()
6959 
    oprot.trans.flush()
6960 
 
6961 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6962 
    args = updateEbayItem_args()
6963 
    args.read(iprot)
6964 
    iprot.readMessageEnd()
6965 
    result = updateEbayItem_result()
6966 
    self._handler.updateEbayItem(args.ebayItem)
6967 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6968 
    result.write(oprot)
6969 
    oprot.writeMessageEnd()
6970 
    oprot.trans.flush()
6971 
 
8139 kshitij.so 6972 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6973 
    args = getAmazonListedItems_args()
6974 
    args.read(iprot)
6975 
    iprot.readMessageEnd()
6976 
    result = getAmazonListedItems_result()
6977 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6978 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
7977 kshitij.so 6982 
 
8168 kshitij.so 6983 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6984 
    args = updateAmazonAttributesInBulk_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = updateAmazonAttributesInBulk_result()
6988 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6989 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
8139 kshitij.so 6993 
 
8379 vikram.rag 6994 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6995 
    args = getAllItemstoListOnFba_args()
6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
6998 
    result = getAllItemstoListOnFba_result()
6999 
    result.success = self._handler.getAllItemstoListOnFba()
7000 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7001 
    result.write(oprot)
7002 
    oprot.writeMessageEnd()
7003 
    oprot.trans.flush()
8168 kshitij.so 7004 
 
8379 vikram.rag 7005 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7006 
    args = getAllItemstoListOnNonFba_args()
7007 
    args.read(iprot)
7008 
    iprot.readMessageEnd()
7009 
    result = getAllItemstoListOnNonFba_result()
7010 
    result.success = self._handler.getAllItemstoListOnNonFba()
7011 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7012 
    result.write(oprot)
7013 
    oprot.writeMessageEnd()
7014 
    oprot.trans.flush()
7015 
 
8619 kshitij.so 7016 
  def process_updateAsin(self, seqid, iprot, oprot):
7017 
    args = updateAsin_args()
7018 
    args.read(iprot)
7019 
    iprot.readMessageEnd()
7020 
    result = updateAsin_result()
7021 
    self._handler.updateAsin(args.item)
7022 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7023 
    result.write(oprot)
7024 
    oprot.writeMessageEnd()
7025 
    oprot.trans.flush()
8616 vikram.rag 7026 
 
8739 vikram.rag 7027 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7028 
    args = addOrUpdateSnapdealItem_args()
7029 
    args.read(iprot)
7030 
    iprot.readMessageEnd()
7031 
    result = addOrUpdateSnapdealItem_result()
7032 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7033 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7034 
    result.write(oprot)
7035 
    oprot.writeMessageEnd()
7036 
    oprot.trans.flush()
8619 kshitij.so 7037 
 
8739 vikram.rag 7038 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7039 
    args = getSnapdealItem_args()
7040 
    args.read(iprot)
7041 
    iprot.readMessageEnd()
7042 
    result = getSnapdealItem_result()
7043 
    result.success = self._handler.getSnapdealItem(args.item_id)
7044 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7045 
    result.write(oprot)
7046 
    oprot.writeMessageEnd()
7047 
    oprot.trans.flush()
7048 
 
9242 kshitij.so 7049 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7050 
    args = getSnapdealItemDetails_args()
7051 
    args.read(iprot)
7052 
    iprot.readMessageEnd()
7053 
    result = getSnapdealItemDetails_result()
7054 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7055 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7056 
    result.write(oprot)
7057 
    oprot.writeMessageEnd()
7058 
    oprot.trans.flush()
7059 
 
8739 vikram.rag 7060 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7061 
    args = getAllSnapdealItems_args()
7062 
    args.read(iprot)
7063 
    iprot.readMessageEnd()
7064 
    result = getAllSnapdealItems_result()
7065 
    result.success = self._handler.getAllSnapdealItems()
7066 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7067 
    result.write(oprot)
7068 
    oprot.writeMessageEnd()
7069 
    oprot.trans.flush()
7070 
 
9242 kshitij.so 7071 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7072 
    args = getSnapdealItems_args()
7073 
    args.read(iprot)
7074 
    iprot.readMessageEnd()
7075 
    result = getSnapdealItems_result()
7076 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7077 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7078 
    result.write(oprot)
7079 
    oprot.writeMessageEnd()
7080 
    oprot.trans.flush()
8739 vikram.rag 7081 
 
9242 kshitij.so 7082 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7083 
    args = searchSnapdealItems_args()
7084 
    args.read(iprot)
7085 
    iprot.readMessageEnd()
7086 
    result = searchSnapdealItems_result()
7087 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7088 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7089 
    result.write(oprot)
7090 
    oprot.writeMessageEnd()
7091 
    oprot.trans.flush()
7092 
 
7093 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7094 
    args = getCountForSnapdealItems_args()
7095 
    args.read(iprot)
7096 
    iprot.readMessageEnd()
7097 
    result = getCountForSnapdealItems_result()
7098 
    result.success = self._handler.getCountForSnapdealItems()
7099 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7100 
    result.write(oprot)
7101 
    oprot.writeMessageEnd()
7102 
    oprot.trans.flush()
7103 
 
7104 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7105 
    args = getSnapdealSearchResultCount_args()
7106 
    args.read(iprot)
7107 
    iprot.readMessageEnd()
7108 
    result = getSnapdealSearchResultCount_result()
7109 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7110 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7111 
    result.write(oprot)
7112 
    oprot.writeMessageEnd()
7113 
    oprot.trans.flush()
7114 
 
9299 kshitij.so 7115 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7116 
    args = getPrefferedInsurerForItem_args()
7117 
    args.read(iprot)
7118 
    iprot.readMessageEnd()
7119 
    result = getPrefferedInsurerForItem_result()
7120 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7121 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7122 
    result.write(oprot)
7123 
    oprot.writeMessageEnd()
7124 
    oprot.trans.flush()
9242 kshitij.so 7125 
 
9456 vikram.rag 7126 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7127 
    args = getSnapdealItembySkuAtSnapdeal_args()
7128 
    args.read(iprot)
7129 
    iprot.readMessageEnd()
7130 
    result = getSnapdealItembySkuAtSnapdeal_result()
7131 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7132 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7133 
    result.write(oprot)
7134 
    oprot.writeMessageEnd()
7135 
    oprot.trans.flush()
9299 kshitij.so 7136 
 
9621 manish.sha 7137 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7138 
    args = getProductFeedSubmit_args()
7139 
    args.read(iprot)
7140 
    iprot.readMessageEnd()
7141 
    result = getProductFeedSubmit_result()
7142 
    try:
7143 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7144 
    except CatalogServiceException, cex:
7145 
      result.cex = cex
7146 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7147 
    result.write(oprot)
7148 
    oprot.writeMessageEnd()
7149 
    oprot.trans.flush()
9456 vikram.rag 7150 
 
9621 manish.sha 7151 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7152 
    args = addProductFeedSubmit_args()
7153 
    args.read(iprot)
7154 
    iprot.readMessageEnd()
7155 
    result = addProductFeedSubmit_result()
7156 
    try:
7157 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7158 
    except CatalogServiceException, cex:
7159 
      result.cex = cex
7160 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7161 
    result.write(oprot)
7162 
    oprot.writeMessageEnd()
7163 
    oprot.trans.flush()
7164 
 
7165 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7166 
    args = updateProductFeedSubmit_args()
7167 
    args.read(iprot)
7168 
    iprot.readMessageEnd()
7169 
    result = updateProductFeedSubmit_result()
7170 
    try:
7171 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7172 
    except CatalogServiceException, cex:
7173 
      result.cex = cex
7174 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7175 
    result.write(oprot)
7176 
    oprot.writeMessageEnd()
7177 
    oprot.trans.flush()
7178 
 
7179 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7180 
    args = deleteProductFeedSubmit_args()
7181 
    args.read(iprot)
7182 
    iprot.readMessageEnd()
7183 
    result = deleteProductFeedSubmit_result()
7184 
    try:
7185 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7186 
    except CatalogServiceException, cex:
7187 
      result.cex = cex
7188 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
7193 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7194 
    args = getAllProductFeedSubmit_args()
7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
7197 
    result = getAllProductFeedSubmit_result()
7198 
    try:
7199 
      result.success = self._handler.getAllProductFeedSubmit()
7200 
    except CatalogServiceException, cex:
7201 
      result.cex = cex
7202 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7203 
    result.write(oprot)
7204 
    oprot.writeMessageEnd()
7205 
    oprot.trans.flush()
7206 
 
9724 kshitij.so 7207 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7208 
    args = getMarketplacedetailsForItem_args()
7209 
    args.read(iprot)
7210 
    iprot.readMessageEnd()
7211 
    result = getMarketplacedetailsForItem_result()
7212 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7213 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7214 
    result.write(oprot)
7215 
    oprot.writeMessageEnd()
7216 
    oprot.trans.flush()
9621 manish.sha 7217 
 
9724 kshitij.so 7218 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7219 
    args = updateMarketplaceAttributesForItem_args()
7220 
    args.read(iprot)
7221 
    iprot.readMessageEnd()
7222 
    result = updateMarketplaceAttributesForItem_result()
7223 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7224 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7225 
    result.write(oprot)
7226 
    oprot.writeMessageEnd()
7227 
    oprot.trans.flush()
7228 
 
9779 kshitij.so 7229 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7230 
    args = getCostingForMarketplace_args()
7231 
    args.read(iprot)
7232 
    iprot.readMessageEnd()
7233 
    result = getCostingForMarketplace_result()
7234 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7235 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7236 
    result.write(oprot)
7237 
    oprot.writeMessageEnd()
7238 
    oprot.trans.flush()
7239 
 
9776 vikram.rag 7240 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7241 
    args = getMarketPlaceItemsForPriceUpdate_args()
7242 
    args.read(iprot)
7243 
    iprot.readMessageEnd()
7244 
    result = getMarketPlaceItemsForPriceUpdate_result()
7245 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7246 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7247 
    result.write(oprot)
7248 
    oprot.writeMessageEnd()
7249 
    oprot.trans.flush()
9724 kshitij.so 7250 
 
9776 vikram.rag 7251 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7252 
    args = updateMarketPlacePriceUpdateStatus_args()
7253 
    args.read(iprot)
7254 
    iprot.readMessageEnd()
7255 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7256 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7257 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
7261 
 
7262 
 
5944 mandeep.dh 7263 
# HELPER FUNCTIONS AND STRUCTURES
7264 
 
7265 
class addItem_args:
7266 
  """
7267 
  Attributes:
7268 
   - item
7269 
  """
7270 
 
7271 
  thrift_spec = (
7272 
    None, # 0
7273 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7274 
  )
7275 
 
7276 
  def __init__(self, item=None,):
7277 
    self.item = item
7278 
 
7279 
  def read(self, iprot):
7280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7282 
      return
7283 
    iprot.readStructBegin()
7284 
    while True:
7285 
      (fname, ftype, fid) = iprot.readFieldBegin()
7286 
      if ftype == TType.STOP:
7287 
        break
7288 
      if fid == 1:
7289 
        if ftype == TType.STRUCT:
7290 
          self.item = Item()
7291 
          self.item.read(iprot)
7292 
        else:
7293 
          iprot.skip(ftype)
7294 
      else:
7295 
        iprot.skip(ftype)
7296 
      iprot.readFieldEnd()
7297 
    iprot.readStructEnd()
7298 
 
7299 
  def write(self, oprot):
7300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7302 
      return
7303 
    oprot.writeStructBegin('addItem_args')
7304 
    if self.item is not None:
7305 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7306 
      self.item.write(oprot)
7307 
      oprot.writeFieldEnd()
7308 
    oprot.writeFieldStop()
7309 
    oprot.writeStructEnd()
7310 
 
7311 
  def validate(self):
7312 
    return
7313 
 
7314 
 
7315 
  def __repr__(self):
7316 
    L = ['%s=%r' % (key, value)
7317 
      for key, value in self.__dict__.iteritems()]
7318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7319 
 
7320 
  def __eq__(self, other):
7321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7322 
 
7323 
  def __ne__(self, other):
7324 
    return not (self == other)
7325 
 
7326 
class addItem_result:
7327 
  """
7328 
  Attributes:
7329 
   - success
7330 
   - cex
7331 
  """
7332 
 
7333 
  thrift_spec = (
7334 
    (0, TType.I64, 'success', None, None, ), # 0
7335 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7336 
  )
7337 
 
7338 
  def __init__(self, success=None, cex=None,):
7339 
    self.success = success
7340 
    self.cex = cex
7341 
 
7342 
  def read(self, iprot):
7343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7345 
      return
7346 
    iprot.readStructBegin()
7347 
    while True:
7348 
      (fname, ftype, fid) = iprot.readFieldBegin()
7349 
      if ftype == TType.STOP:
7350 
        break
7351 
      if fid == 0:
7352 
        if ftype == TType.I64:
7353 
          self.success = iprot.readI64();
7354 
        else:
7355 
          iprot.skip(ftype)
7356 
      elif fid == 1:
7357 
        if ftype == TType.STRUCT:
7358 
          self.cex = CatalogServiceException()
7359 
          self.cex.read(iprot)
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      else:
7363 
        iprot.skip(ftype)
7364 
      iprot.readFieldEnd()
7365 
    iprot.readStructEnd()
7366 
 
7367 
  def write(self, oprot):
7368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7370 
      return
7371 
    oprot.writeStructBegin('addItem_result')
7372 
    if self.success is not None:
7373 
      oprot.writeFieldBegin('success', TType.I64, 0)
7374 
      oprot.writeI64(self.success)
7375 
      oprot.writeFieldEnd()
7376 
    if self.cex is not None:
7377 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7378 
      self.cex.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class updateItem_args:
7399 
  """
7400 
  Attributes:
7401 
   - item
7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    None, # 0
7406 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7407 
  )
7408 
 
7409 
  def __init__(self, item=None,):
7410 
    self.item = item
7411 
 
7412 
  def read(self, iprot):
7413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7415 
      return
7416 
    iprot.readStructBegin()
7417 
    while True:
7418 
      (fname, ftype, fid) = iprot.readFieldBegin()
7419 
      if ftype == TType.STOP:
7420 
        break
7421 
      if fid == 1:
7422 
        if ftype == TType.STRUCT:
7423 
          self.item = Item()
7424 
          self.item.read(iprot)
7425 
        else:
7426 
          iprot.skip(ftype)
7427 
      else:
7428 
        iprot.skip(ftype)
7429 
      iprot.readFieldEnd()
7430 
    iprot.readStructEnd()
7431 
 
7432 
  def write(self, oprot):
7433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7435 
      return
7436 
    oprot.writeStructBegin('updateItem_args')
7437 
    if self.item is not None:
7438 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7439 
      self.item.write(oprot)
7440 
      oprot.writeFieldEnd()
7441 
    oprot.writeFieldStop()
7442 
    oprot.writeStructEnd()
7443 
 
7444 
  def validate(self):
7445 
    return
7446 
 
7447 
 
7448 
  def __repr__(self):
7449 
    L = ['%s=%r' % (key, value)
7450 
      for key, value in self.__dict__.iteritems()]
7451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7452 
 
7453 
  def __eq__(self, other):
7454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7455 
 
7456 
  def __ne__(self, other):
7457 
    return not (self == other)
7458 
 
7459 
class updateItem_result:
7460 
  """
7461 
  Attributes:
7462 
   - success
7463 
   - cex
7464 
  """
7465 
 
7466 
  thrift_spec = (
7467 
    (0, TType.I64, 'success', None, None, ), # 0
7468 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7469 
  )
7470 
 
7471 
  def __init__(self, success=None, cex=None,):
7472 
    self.success = success
7473 
    self.cex = cex
7474 
 
7475 
  def read(self, iprot):
7476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7478 
      return
7479 
    iprot.readStructBegin()
7480 
    while True:
7481 
      (fname, ftype, fid) = iprot.readFieldBegin()
7482 
      if ftype == TType.STOP:
7483 
        break
7484 
      if fid == 0:
7485 
        if ftype == TType.I64:
7486 
          self.success = iprot.readI64();
7487 
        else:
7488 
          iprot.skip(ftype)
7489 
      elif fid == 1:
7490 
        if ftype == TType.STRUCT:
7491 
          self.cex = CatalogServiceException()
7492 
          self.cex.read(iprot)
7493 
        else:
7494 
          iprot.skip(ftype)
7495 
      else:
7496 
        iprot.skip(ftype)
7497 
      iprot.readFieldEnd()
7498 
    iprot.readStructEnd()
7499 
 
7500 
  def write(self, oprot):
7501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7503 
      return
7504 
    oprot.writeStructBegin('updateItem_result')
7505 
    if self.success is not None:
7506 
      oprot.writeFieldBegin('success', TType.I64, 0)
7507 
      oprot.writeI64(self.success)
7508 
      oprot.writeFieldEnd()
7509 
    if self.cex is not None:
7510 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7511 
      self.cex.write(oprot)
7512 
      oprot.writeFieldEnd()
7513 
    oprot.writeFieldStop()
7514 
    oprot.writeStructEnd()
7515 
 
7516 
  def validate(self):
7517 
    return
7518 
 
7519 
 
7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
7531 
class isActive_args:
7532 
  """
7533 
  Attributes:
7534 
   - itemId
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    None, # 0
7539 
    (1, TType.I64, 'itemId', None, None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, itemId=None,):
7543 
    self.itemId = itemId
7544 
 
7545 
  def read(self, iprot):
7546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7548 
      return
7549 
    iprot.readStructBegin()
7550 
    while True:
7551 
      (fname, ftype, fid) = iprot.readFieldBegin()
7552 
      if ftype == TType.STOP:
7553 
        break
7554 
      if fid == 1:
7555 
        if ftype == TType.I64:
7556 
          self.itemId = iprot.readI64();
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      else:
7560 
        iprot.skip(ftype)
7561 
      iprot.readFieldEnd()
7562 
    iprot.readStructEnd()
7563 
 
7564 
  def write(self, oprot):
7565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7567 
      return
7568 
    oprot.writeStructBegin('isActive_args')
7569 
    if self.itemId is not None:
7570 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7571 
      oprot.writeI64(self.itemId)
7572 
      oprot.writeFieldEnd()
7573 
    oprot.writeFieldStop()
7574 
    oprot.writeStructEnd()
7575 
 
7576 
  def validate(self):
7577 
    return
7578 
 
7579 
 
7580 
  def __repr__(self):
7581 
    L = ['%s=%r' % (key, value)
7582 
      for key, value in self.__dict__.iteritems()]
7583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7584 
 
7585 
  def __eq__(self, other):
7586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7587 
 
7588 
  def __ne__(self, other):
7589 
    return not (self == other)
7590 
 
7591 
class isActive_result:
7592 
  """
7593 
  Attributes:
7594 
   - success
7595 
   - isex
7596 
  """
7597 
 
7598 
  thrift_spec = (
7599 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7600 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7601 
  )
7602 
 
7603 
  def __init__(self, success=None, isex=None,):
7604 
    self.success = success
7605 
    self.isex = isex
7606 
 
7607 
  def read(self, iprot):
7608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7610 
      return
7611 
    iprot.readStructBegin()
7612 
    while True:
7613 
      (fname, ftype, fid) = iprot.readFieldBegin()
7614 
      if ftype == TType.STOP:
7615 
        break
7616 
      if fid == 0:
7617 
        if ftype == TType.STRUCT:
7618 
          self.success = ItemShippingInfo()
7619 
          self.success.read(iprot)
7620 
        else:
7621 
          iprot.skip(ftype)
7622 
      elif fid == 1:
7623 
        if ftype == TType.STRUCT:
7624 
          self.isex = CatalogServiceException()
7625 
          self.isex.read(iprot)
7626 
        else:
7627 
          iprot.skip(ftype)
7628 
      else:
7629 
        iprot.skip(ftype)
7630 
      iprot.readFieldEnd()
7631 
    iprot.readStructEnd()
7632 
 
7633 
  def write(self, oprot):
7634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7636 
      return
7637 
    oprot.writeStructBegin('isActive_result')
7638 
    if self.success is not None:
7639 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7640 
      self.success.write(oprot)
7641 
      oprot.writeFieldEnd()
7642 
    if self.isex is not None:
7643 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7644 
      self.isex.write(oprot)
7645 
      oprot.writeFieldEnd()
7646 
    oprot.writeFieldStop()
7647 
    oprot.writeStructEnd()
7648 
 
7649 
  def validate(self):
7650 
    return
7651 
 
7652 
 
7653 
  def __repr__(self):
7654 
    L = ['%s=%r' % (key, value)
7655 
      for key, value in self.__dict__.iteritems()]
7656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7657 
 
7658 
  def __eq__(self, other):
7659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7660 
 
7661 
  def __ne__(self, other):
7662 
    return not (self == other)
7663 
 
7438 amit.gupta 7664 
class getItemsStatus_args:
7665 
  """
7666 
  Attributes:
7667 
   - itemIds
7668 
  """
7669 
 
7670 
  thrift_spec = (
7671 
    None, # 0
7672 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7673 
  )
7674 
 
7675 
  def __init__(self, itemIds=None,):
7676 
    self.itemIds = itemIds
7677 
 
7678 
  def read(self, iprot):
7679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7681 
      return
7682 
    iprot.readStructBegin()
7683 
    while True:
7684 
      (fname, ftype, fid) = iprot.readFieldBegin()
7685 
      if ftype == TType.STOP:
7686 
        break
7687 
      if fid == 1:
7688 
        if ftype == TType.LIST:
7689 
          self.itemIds = []
8590 kshitij.so 7690 
          (_etype33, _size30) = iprot.readListBegin()
7691 
          for _i34 in xrange(_size30):
7692 
            _elem35 = iprot.readI64();
7693 
            self.itemIds.append(_elem35)
7438 amit.gupta 7694 
          iprot.readListEnd()
7695 
        else:
7696 
          iprot.skip(ftype)
7697 
      else:
7698 
        iprot.skip(ftype)
7699 
      iprot.readFieldEnd()
7700 
    iprot.readStructEnd()
7701 
 
7702 
  def write(self, oprot):
7703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7705 
      return
7706 
    oprot.writeStructBegin('getItemsStatus_args')
7707 
    if self.itemIds is not None:
7708 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7709 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7710 
      for iter36 in self.itemIds:
7711 
        oprot.writeI64(iter36)
7438 amit.gupta 7712 
      oprot.writeListEnd()
7713 
      oprot.writeFieldEnd()
7714 
    oprot.writeFieldStop()
7715 
    oprot.writeStructEnd()
7716 
 
7717 
  def validate(self):
7718 
    return
7719 
 
7720 
 
7721 
  def __repr__(self):
7722 
    L = ['%s=%r' % (key, value)
7723 
      for key, value in self.__dict__.iteritems()]
7724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7725 
 
7726 
  def __eq__(self, other):
7727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7728 
 
7729 
  def __ne__(self, other):
7730 
    return not (self == other)
7731 
 
7732 
class getItemsStatus_result:
7733 
  """
7734 
  Attributes:
7735 
   - success
7736 
   - isex
7737 
  """
7738 
 
7739 
  thrift_spec = (
7740 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7741 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7742 
  )
7743 
 
7744 
  def __init__(self, success=None, isex=None,):
7745 
    self.success = success
7746 
    self.isex = isex
7747 
 
7748 
  def read(self, iprot):
7749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7751 
      return
7752 
    iprot.readStructBegin()
7753 
    while True:
7754 
      (fname, ftype, fid) = iprot.readFieldBegin()
7755 
      if ftype == TType.STOP:
7756 
        break
7757 
      if fid == 0:
7758 
        if ftype == TType.MAP:
7759 
          self.success = {}
8590 kshitij.so 7760 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7761 
          for _i41 in xrange(_size37):
7762 
            _key42 = iprot.readI64();
7763 
            _val43 = iprot.readBool();
7764 
            self.success[_key42] = _val43
7438 amit.gupta 7765 
          iprot.readMapEnd()
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      elif fid == 1:
7769 
        if ftype == TType.STRUCT:
7770 
          self.isex = CatalogServiceException()
7771 
          self.isex.read(iprot)
7772 
        else:
7773 
          iprot.skip(ftype)
7774 
      else:
7775 
        iprot.skip(ftype)
7776 
      iprot.readFieldEnd()
7777 
    iprot.readStructEnd()
7778 
 
7779 
  def write(self, oprot):
7780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7782 
      return
7783 
    oprot.writeStructBegin('getItemsStatus_result')
7784 
    if self.success is not None:
7785 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7786 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7787 
      for kiter44,viter45 in self.success.items():
7788 
        oprot.writeI64(kiter44)
7789 
        oprot.writeBool(viter45)
7438 amit.gupta 7790 
      oprot.writeMapEnd()
7791 
      oprot.writeFieldEnd()
7792 
    if self.isex is not None:
7793 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7794 
      self.isex.write(oprot)
7795 
      oprot.writeFieldEnd()
7796 
    oprot.writeFieldStop()
7797 
    oprot.writeStructEnd()
7798 
 
7799 
  def validate(self):
7800 
    return
7801 
 
7802 
 
7803 
  def __repr__(self):
7804 
    L = ['%s=%r' % (key, value)
7805 
      for key, value in self.__dict__.iteritems()]
7806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7807 
 
7808 
  def __eq__(self, other):
7809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7810 
 
7811 
  def __ne__(self, other):
7812 
    return not (self == other)
7813 
 
5944 mandeep.dh 7814 
class getItemStatusDescription_args:
7815 
  """
7816 
  Attributes:
7817 
   - itemId
7818 
  """
7819 
 
7820 
  thrift_spec = (
7821 
    None, # 0
7822 
    (1, TType.I64, 'itemId', None, None, ), # 1
7823 
  )
7824 
 
7825 
  def __init__(self, itemId=None,):
7826 
    self.itemId = itemId
7827 
 
7828 
  def read(self, iprot):
7829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7831 
      return
7832 
    iprot.readStructBegin()
7833 
    while True:
7834 
      (fname, ftype, fid) = iprot.readFieldBegin()
7835 
      if ftype == TType.STOP:
7836 
        break
7837 
      if fid == 1:
7838 
        if ftype == TType.I64:
7839 
          self.itemId = iprot.readI64();
7840 
        else:
7841 
          iprot.skip(ftype)
7842 
      else:
7843 
        iprot.skip(ftype)
7844 
      iprot.readFieldEnd()
7845 
    iprot.readStructEnd()
7846 
 
7847 
  def write(self, oprot):
7848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7850 
      return
7851 
    oprot.writeStructBegin('getItemStatusDescription_args')
7852 
    if self.itemId is not None:
7853 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7854 
      oprot.writeI64(self.itemId)
7855 
      oprot.writeFieldEnd()
7856 
    oprot.writeFieldStop()
7857 
    oprot.writeStructEnd()
7858 
 
7859 
  def validate(self):
7860 
    return
7861 
 
7862 
 
7863 
  def __repr__(self):
7864 
    L = ['%s=%r' % (key, value)
7865 
      for key, value in self.__dict__.iteritems()]
7866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7867 
 
7868 
  def __eq__(self, other):
7869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7870 
 
7871 
  def __ne__(self, other):
7872 
    return not (self == other)
7873 
 
7874 
class getItemStatusDescription_result:
7875 
  """
7876 
  Attributes:
7877 
   - success
7878 
   - isex
7879 
  """
7880 
 
7881 
  thrift_spec = (
7882 
    (0, TType.STRING, 'success', None, None, ), # 0
7883 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7884 
  )
7885 
 
7886 
  def __init__(self, success=None, isex=None,):
7887 
    self.success = success
7888 
    self.isex = isex
7889 
 
7890 
  def read(self, iprot):
7891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7893 
      return
7894 
    iprot.readStructBegin()
7895 
    while True:
7896 
      (fname, ftype, fid) = iprot.readFieldBegin()
7897 
      if ftype == TType.STOP:
7898 
        break
7899 
      if fid == 0:
7900 
        if ftype == TType.STRING:
7901 
          self.success = iprot.readString();
7902 
        else:
7903 
          iprot.skip(ftype)
7904 
      elif fid == 1:
7905 
        if ftype == TType.STRUCT:
7906 
          self.isex = CatalogServiceException()
7907 
          self.isex.read(iprot)
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      else:
7911 
        iprot.skip(ftype)
7912 
      iprot.readFieldEnd()
7913 
    iprot.readStructEnd()
7914 
 
7915 
  def write(self, oprot):
7916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7918 
      return
7919 
    oprot.writeStructBegin('getItemStatusDescription_result')
7920 
    if self.success is not None:
7921 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7922 
      oprot.writeString(self.success)
7923 
      oprot.writeFieldEnd()
7924 
    if self.isex is not None:
7925 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7926 
      self.isex.write(oprot)
7927 
      oprot.writeFieldEnd()
7928 
    oprot.writeFieldStop()
7929 
    oprot.writeStructEnd()
7930 
 
7931 
  def validate(self):
7932 
    return
7933 
 
7934 
 
7935 
  def __repr__(self):
7936 
    L = ['%s=%r' % (key, value)
7937 
      for key, value in self.__dict__.iteritems()]
7938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7939 
 
7940 
  def __eq__(self, other):
7941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7942 
 
7943 
  def __ne__(self, other):
7944 
    return not (self == other)
7945 
 
7946 
class startItemOn_args:
7947 
  """
7948 
  Attributes:
7949 
   - item_id
7950 
   - timestamp
7951 
  """
7952 
 
7953 
  thrift_spec = (
7954 
    None, # 0
7955 
    (1, TType.I64, 'item_id', None, None, ), # 1
7956 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7957 
  )
7958 
 
7959 
  def __init__(self, item_id=None, timestamp=None,):
7960 
    self.item_id = item_id
7961 
    self.timestamp = timestamp
7962 
 
7963 
  def read(self, iprot):
7964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7966 
      return
7967 
    iprot.readStructBegin()
7968 
    while True:
7969 
      (fname, ftype, fid) = iprot.readFieldBegin()
7970 
      if ftype == TType.STOP:
7971 
        break
7972 
      if fid == 1:
7973 
        if ftype == TType.I64:
7974 
          self.item_id = iprot.readI64();
7975 
        else:
7976 
          iprot.skip(ftype)
7977 
      elif fid == 2:
7978 
        if ftype == TType.I64:
7979 
          self.timestamp = iprot.readI64();
7980 
        else:
7981 
          iprot.skip(ftype)
7982 
      else:
7983 
        iprot.skip(ftype)
7984 
      iprot.readFieldEnd()
7985 
    iprot.readStructEnd()
7986 
 
7987 
  def write(self, oprot):
7988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7990 
      return
7991 
    oprot.writeStructBegin('startItemOn_args')
7992 
    if self.item_id is not None:
7993 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7994 
      oprot.writeI64(self.item_id)
7995 
      oprot.writeFieldEnd()
7996 
    if self.timestamp is not None:
7997 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7998 
      oprot.writeI64(self.timestamp)
7999 
      oprot.writeFieldEnd()
8000 
    oprot.writeFieldStop()
8001 
    oprot.writeStructEnd()
8002 
 
8003 
  def validate(self):
8004 
    return
8005 
 
8006 
 
8007 
  def __repr__(self):
8008 
    L = ['%s=%r' % (key, value)
8009 
      for key, value in self.__dict__.iteritems()]
8010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8011 
 
8012 
  def __eq__(self, other):
8013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8014 
 
8015 
  def __ne__(self, other):
8016 
    return not (self == other)
8017 
 
8018 
class startItemOn_result:
8019 
  """
8020 
  Attributes:
8021 
   - cex
8022 
  """
8023 
 
8024 
  thrift_spec = (
8025 
    None, # 0
8026 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8027 
  )
8028 
 
8029 
  def __init__(self, cex=None,):
8030 
    self.cex = cex
8031 
 
8032 
  def read(self, iprot):
8033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8035 
      return
8036 
    iprot.readStructBegin()
8037 
    while True:
8038 
      (fname, ftype, fid) = iprot.readFieldBegin()
8039 
      if ftype == TType.STOP:
8040 
        break
8041 
      if fid == 1:
8042 
        if ftype == TType.STRUCT:
8043 
          self.cex = CatalogServiceException()
8044 
          self.cex.read(iprot)
8045 
        else:
8046 
          iprot.skip(ftype)
8047 
      else:
8048 
        iprot.skip(ftype)
8049 
      iprot.readFieldEnd()
8050 
    iprot.readStructEnd()
8051 
 
8052 
  def write(self, oprot):
8053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8055 
      return
8056 
    oprot.writeStructBegin('startItemOn_result')
8057 
    if self.cex is not None:
8058 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8059 
      self.cex.write(oprot)
8060 
      oprot.writeFieldEnd()
8061 
    oprot.writeFieldStop()
8062 
    oprot.writeStructEnd()
8063 
 
8064 
  def validate(self):
8065 
    return
8066 
 
8067 
 
8068 
  def __repr__(self):
8069 
    L = ['%s=%r' % (key, value)
8070 
      for key, value in self.__dict__.iteritems()]
8071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8072 
 
8073 
  def __eq__(self, other):
8074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8075 
 
8076 
  def __ne__(self, other):
8077 
    return not (self == other)
8078 
 
8079 
class retireItemOn_args:
8080 
  """
8081 
  Attributes:
8082 
   - item_id
8083 
   - timestamp
8084 
  """
8085 
 
8086 
  thrift_spec = (
8087 
    None, # 0
8088 
    (1, TType.I64, 'item_id', None, None, ), # 1
8089 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8090 
  )
8091 
 
8092 
  def __init__(self, item_id=None, timestamp=None,):
8093 
    self.item_id = item_id
8094 
    self.timestamp = timestamp
8095 
 
8096 
  def read(self, iprot):
8097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8099 
      return
8100 
    iprot.readStructBegin()
8101 
    while True:
8102 
      (fname, ftype, fid) = iprot.readFieldBegin()
8103 
      if ftype == TType.STOP:
8104 
        break
8105 
      if fid == 1:
8106 
        if ftype == TType.I64:
8107 
          self.item_id = iprot.readI64();
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 2:
8111 
        if ftype == TType.I64:
8112 
          self.timestamp = iprot.readI64();
8113 
        else:
8114 
          iprot.skip(ftype)
8115 
      else:
8116 
        iprot.skip(ftype)
8117 
      iprot.readFieldEnd()
8118 
    iprot.readStructEnd()
8119 
 
8120 
  def write(self, oprot):
8121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8123 
      return
8124 
    oprot.writeStructBegin('retireItemOn_args')
8125 
    if self.item_id is not None:
8126 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8127 
      oprot.writeI64(self.item_id)
8128 
      oprot.writeFieldEnd()
8129 
    if self.timestamp is not None:
8130 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8131 
      oprot.writeI64(self.timestamp)
8132 
      oprot.writeFieldEnd()
8133 
    oprot.writeFieldStop()
8134 
    oprot.writeStructEnd()
8135 
 
8136 
  def validate(self):
8137 
    return
8138 
 
8139 
 
8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
8151 
class retireItemOn_result:
8152 
  """
8153 
  Attributes:
8154 
   - cex
8155 
  """
8156 
 
8157 
  thrift_spec = (
8158 
    None, # 0
8159 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8160 
  )
8161 
 
8162 
  def __init__(self, cex=None,):
8163 
    self.cex = cex
8164 
 
8165 
  def read(self, iprot):
8166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8168 
      return
8169 
    iprot.readStructBegin()
8170 
    while True:
8171 
      (fname, ftype, fid) = iprot.readFieldBegin()
8172 
      if ftype == TType.STOP:
8173 
        break
8174 
      if fid == 1:
8175 
        if ftype == TType.STRUCT:
8176 
          self.cex = CatalogServiceException()
8177 
          self.cex.read(iprot)
8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      else:
8181 
        iprot.skip(ftype)
8182 
      iprot.readFieldEnd()
8183 
    iprot.readStructEnd()
8184 
 
8185 
  def write(self, oprot):
8186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8188 
      return
8189 
    oprot.writeStructBegin('retireItemOn_result')
8190 
    if self.cex is not None:
8191 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8192 
      self.cex.write(oprot)
8193 
      oprot.writeFieldEnd()
8194 
    oprot.writeFieldStop()
8195 
    oprot.writeStructEnd()
8196 
 
8197 
  def validate(self):
8198 
    return
8199 
 
8200 
 
8201 
  def __repr__(self):
8202 
    L = ['%s=%r' % (key, value)
8203 
      for key, value in self.__dict__.iteritems()]
8204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8205 
 
8206 
  def __eq__(self, other):
8207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8208 
 
8209 
  def __ne__(self, other):
8210 
    return not (self == other)
8211 
 
8212 
class changeItemStatus_args:
8213 
  """
8214 
  Attributes:
8215 
   - item_id
8216 
   - timestamp
8217 
   - newstatus
8218 
  """
8219 
 
8220 
  thrift_spec = (
8221 
    None, # 0
8222 
    (1, TType.I64, 'item_id', None, None, ), # 1
8223 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8224 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8225 
  )
8226 
 
8227 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8228 
    self.item_id = item_id
8229 
    self.timestamp = timestamp
8230 
    self.newstatus = newstatus
8231 
 
8232 
  def read(self, iprot):
8233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8235 
      return
8236 
    iprot.readStructBegin()
8237 
    while True:
8238 
      (fname, ftype, fid) = iprot.readFieldBegin()
8239 
      if ftype == TType.STOP:
8240 
        break
8241 
      if fid == 1:
8242 
        if ftype == TType.I64:
8243 
          self.item_id = iprot.readI64();
8244 
        else:
8245 
          iprot.skip(ftype)
8246 
      elif fid == 2:
8247 
        if ftype == TType.I64:
8248 
          self.timestamp = iprot.readI64();
8249 
        else:
8250 
          iprot.skip(ftype)
8251 
      elif fid == 3:
8252 
        if ftype == TType.I32:
8253 
          self.newstatus = iprot.readI32();
8254 
        else:
8255 
          iprot.skip(ftype)
8256 
      else:
8257 
        iprot.skip(ftype)
8258 
      iprot.readFieldEnd()
8259 
    iprot.readStructEnd()
8260 
 
8261 
  def write(self, oprot):
8262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8264 
      return
8265 
    oprot.writeStructBegin('changeItemStatus_args')
8266 
    if self.item_id is not None:
8267 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8268 
      oprot.writeI64(self.item_id)
8269 
      oprot.writeFieldEnd()
8270 
    if self.timestamp is not None:
8271 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8272 
      oprot.writeI64(self.timestamp)
8273 
      oprot.writeFieldEnd()
8274 
    if self.newstatus is not None:
8275 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8276 
      oprot.writeI32(self.newstatus)
8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
8296 
class changeItemStatus_result:
8297 
  """
8298 
  Attributes:
8299 
   - cex
8300 
  """
8301 
 
8302 
  thrift_spec = (
8303 
    None, # 0
8304 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8305 
  )
8306 
 
8307 
  def __init__(self, cex=None,):
8308 
    self.cex = cex
8309 
 
8310 
  def read(self, iprot):
8311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8313 
      return
8314 
    iprot.readStructBegin()
8315 
    while True:
8316 
      (fname, ftype, fid) = iprot.readFieldBegin()
8317 
      if ftype == TType.STOP:
8318 
        break
8319 
      if fid == 1:
8320 
        if ftype == TType.STRUCT:
8321 
          self.cex = CatalogServiceException()
8322 
          self.cex.read(iprot)
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      else:
8326 
        iprot.skip(ftype)
8327 
      iprot.readFieldEnd()
8328 
    iprot.readStructEnd()
8329 
 
8330 
  def write(self, oprot):
8331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8333 
      return
8334 
    oprot.writeStructBegin('changeItemStatus_result')
8335 
    if self.cex is not None:
8336 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8337 
      self.cex.write(oprot)
8338 
      oprot.writeFieldEnd()
8339 
    oprot.writeFieldStop()
8340 
    oprot.writeStructEnd()
8341 
 
8342 
  def validate(self):
8343 
    return
8344 
 
8345 
 
8346 
  def __repr__(self):
8347 
    L = ['%s=%r' % (key, value)
8348 
      for key, value in self.__dict__.iteritems()]
8349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8350 
 
8351 
  def __eq__(self, other):
8352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8353 
 
8354 
  def __ne__(self, other):
8355 
    return not (self == other)
8356 
 
8357 
class getItem_args:
8358 
  """
8359 
  Attributes:
8360 
   - item_id
8361 
  """
8362 
 
8363 
  thrift_spec = (
8364 
    None, # 0
8365 
    (1, TType.I64, 'item_id', None, None, ), # 1
8366 
  )
8367 
 
8368 
  def __init__(self, item_id=None,):
8369 
    self.item_id = item_id
8370 
 
8371 
  def read(self, iprot):
8372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8374 
      return
8375 
    iprot.readStructBegin()
8376 
    while True:
8377 
      (fname, ftype, fid) = iprot.readFieldBegin()
8378 
      if ftype == TType.STOP:
8379 
        break
8380 
      if fid == 1:
8381 
        if ftype == TType.I64:
8382 
          self.item_id = iprot.readI64();
8383 
        else:
8384 
          iprot.skip(ftype)
8385 
      else:
8386 
        iprot.skip(ftype)
8387 
      iprot.readFieldEnd()
8388 
    iprot.readStructEnd()
8389 
 
8390 
  def write(self, oprot):
8391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8393 
      return
8394 
    oprot.writeStructBegin('getItem_args')
8395 
    if self.item_id is not None:
8396 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8397 
      oprot.writeI64(self.item_id)
8398 
      oprot.writeFieldEnd()
8399 
    oprot.writeFieldStop()
8400 
    oprot.writeStructEnd()
8401 
 
8402 
  def validate(self):
8403 
    return
8404 
 
8405 
 
8406 
  def __repr__(self):
8407 
    L = ['%s=%r' % (key, value)
8408 
      for key, value in self.__dict__.iteritems()]
8409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8410 
 
8411 
  def __eq__(self, other):
8412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8413 
 
8414 
  def __ne__(self, other):
8415 
    return not (self == other)
8416 
 
8417 
class getItem_result:
8418 
  """
8419 
  Attributes:
8420 
   - success
8421 
   - cex
8422 
  """
8423 
 
8424 
  thrift_spec = (
8425 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
8426 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8427 
  )
8428 
 
8429 
  def __init__(self, success=None, cex=None,):
8430 
    self.success = success
8431 
    self.cex = cex
8432 
 
8433 
  def read(self, iprot):
8434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8436 
      return
8437 
    iprot.readStructBegin()
8438 
    while True:
8439 
      (fname, ftype, fid) = iprot.readFieldBegin()
8440 
      if ftype == TType.STOP:
8441 
        break
8442 
      if fid == 0:
8443 
        if ftype == TType.STRUCT:
8444 
          self.success = Item()
8445 
          self.success.read(iprot)
8446 
        else:
8447 
          iprot.skip(ftype)
8448 
      elif fid == 1:
8449 
        if ftype == TType.STRUCT:
8450 
          self.cex = CatalogServiceException()
8451 
          self.cex.read(iprot)
8452 
        else:
8453 
          iprot.skip(ftype)
8454 
      else:
8455 
        iprot.skip(ftype)
8456 
      iprot.readFieldEnd()
8457 
    iprot.readStructEnd()
8458 
 
8459 
  def write(self, oprot):
8460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8462 
      return
8463 
    oprot.writeStructBegin('getItem_result')
8464 
    if self.success is not None:
8465 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8466 
      self.success.write(oprot)
8467 
      oprot.writeFieldEnd()
8468 
    if self.cex is not None:
8469 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8470 
      self.cex.write(oprot)
8471 
      oprot.writeFieldEnd()
8472 
    oprot.writeFieldStop()
8473 
    oprot.writeStructEnd()
8474 
 
8475 
  def validate(self):
8476 
    return
8477 
 
8478 
 
8479 
  def __repr__(self):
8480 
    L = ['%s=%r' % (key, value)
8481 
      for key, value in self.__dict__.iteritems()]
8482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8483 
 
8484 
  def __eq__(self, other):
8485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8486 
 
8487 
  def __ne__(self, other):
8488 
    return not (self == other)
8489 
 
8490 
class getItemsByCatalogId_args:
8491 
  """
8492 
  Attributes:
8493 
   - catalog_item_id
8494 
  """
8495 
 
8496 
  thrift_spec = (
8497 
    None, # 0
8498 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8499 
  )
8500 
 
8501 
  def __init__(self, catalog_item_id=None,):
8502 
    self.catalog_item_id = catalog_item_id
8503 
 
8504 
  def read(self, iprot):
8505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8507 
      return
8508 
    iprot.readStructBegin()
8509 
    while True:
8510 
      (fname, ftype, fid) = iprot.readFieldBegin()
8511 
      if ftype == TType.STOP:
8512 
        break
8513 
      if fid == 1:
8514 
        if ftype == TType.I64:
8515 
          self.catalog_item_id = iprot.readI64();
8516 
        else:
8517 
          iprot.skip(ftype)
8518 
      else:
8519 
        iprot.skip(ftype)
8520 
      iprot.readFieldEnd()
8521 
    iprot.readStructEnd()
8522 
 
8523 
  def write(self, oprot):
8524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8526 
      return
8527 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8528 
    if self.catalog_item_id is not None:
8529 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8530 
      oprot.writeI64(self.catalog_item_id)
8531 
      oprot.writeFieldEnd()
8532 
    oprot.writeFieldStop()
8533 
    oprot.writeStructEnd()
8534 
 
8535 
  def validate(self):
8536 
    return
8537 
 
8538 
 
8539 
  def __repr__(self):
8540 
    L = ['%s=%r' % (key, value)
8541 
      for key, value in self.__dict__.iteritems()]
8542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8543 
 
8544 
  def __eq__(self, other):
8545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8546 
 
8547 
  def __ne__(self, other):
8548 
    return not (self == other)
8549 
 
8550 
class getItemsByCatalogId_result:
8551 
  """
8552 
  Attributes:
8553 
   - success
8554 
   - cex
8555 
  """
8556 
 
8557 
  thrift_spec = (
8558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8559 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8560 
  )
8561 
 
8562 
  def __init__(self, success=None, cex=None,):
8563 
    self.success = success
8564 
    self.cex = cex
8565 
 
8566 
  def read(self, iprot):
8567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8569 
      return
8570 
    iprot.readStructBegin()
8571 
    while True:
8572 
      (fname, ftype, fid) = iprot.readFieldBegin()
8573 
      if ftype == TType.STOP:
8574 
        break
8575 
      if fid == 0:
8576 
        if ftype == TType.LIST:
8577 
          self.success = []
8590 kshitij.so 8578 
          (_etype49, _size46) = iprot.readListBegin()
8579 
          for _i50 in xrange(_size46):
8580 
            _elem51 = Item()
8581 
            _elem51.read(iprot)
8582 
            self.success.append(_elem51)
5944 mandeep.dh 8583 
          iprot.readListEnd()
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      elif fid == 1:
8587 
        if ftype == TType.STRUCT:
8588 
          self.cex = CatalogServiceException()
8589 
          self.cex.read(iprot)
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      else:
8593 
        iprot.skip(ftype)
8594 
      iprot.readFieldEnd()
8595 
    iprot.readStructEnd()
8596 
 
8597 
  def write(self, oprot):
8598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8600 
      return
8601 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8602 
    if self.success is not None:
8603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8605 
      for iter52 in self.success:
8606 
        iter52.write(oprot)
5944 mandeep.dh 8607 
      oprot.writeListEnd()
8608 
      oprot.writeFieldEnd()
8609 
    if self.cex is not None:
8610 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8611 
      self.cex.write(oprot)
8612 
      oprot.writeFieldEnd()
8613 
    oprot.writeFieldStop()
8614 
    oprot.writeStructEnd()
8615 
 
8616 
  def validate(self):
8617 
    return
8618 
 
8619 
 
8620 
  def __repr__(self):
8621 
    L = ['%s=%r' % (key, value)
8622 
      for key, value in self.__dict__.iteritems()]
8623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8624 
 
8625 
  def __eq__(self, other):
8626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8627 
 
8628 
  def __ne__(self, other):
8629 
    return not (self == other)
8630 
 
8631 
class getValidItemsByCatalogId_args:
8632 
  """
8633 
  Attributes:
8634 
   - catalog_item_id
8635 
  """
8636 
 
8637 
  thrift_spec = (
8638 
    None, # 0
8639 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8640 
  )
8641 
 
8642 
  def __init__(self, catalog_item_id=None,):
8643 
    self.catalog_item_id = catalog_item_id
8644 
 
8645 
  def read(self, iprot):
8646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8648 
      return
8649 
    iprot.readStructBegin()
8650 
    while True:
8651 
      (fname, ftype, fid) = iprot.readFieldBegin()
8652 
      if ftype == TType.STOP:
8653 
        break
8654 
      if fid == 1:
8655 
        if ftype == TType.I64:
8656 
          self.catalog_item_id = iprot.readI64();
8657 
        else:
8658 
          iprot.skip(ftype)
8659 
      else:
8660 
        iprot.skip(ftype)
8661 
      iprot.readFieldEnd()
8662 
    iprot.readStructEnd()
8663 
 
8664 
  def write(self, oprot):
8665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8667 
      return
8668 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8669 
    if self.catalog_item_id is not None:
8670 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8671 
      oprot.writeI64(self.catalog_item_id)
8672 
      oprot.writeFieldEnd()
8673 
    oprot.writeFieldStop()
8674 
    oprot.writeStructEnd()
8675 
 
8676 
  def validate(self):
8677 
    return
8678 
 
8679 
 
8680 
  def __repr__(self):
8681 
    L = ['%s=%r' % (key, value)
8682 
      for key, value in self.__dict__.iteritems()]
8683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8684 
 
8685 
  def __eq__(self, other):
8686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8687 
 
8688 
  def __ne__(self, other):
8689 
    return not (self == other)
8690 
 
8691 
class getValidItemsByCatalogId_result:
8692 
  """
8693 
  Attributes:
8694 
   - success
8695 
   - cex
8696 
  """
8697 
 
8698 
  thrift_spec = (
8699 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8700 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8701 
  )
8702 
 
8703 
  def __init__(self, success=None, cex=None,):
8704 
    self.success = success
8705 
    self.cex = cex
8706 
 
8707 
  def read(self, iprot):
8708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8710 
      return
8711 
    iprot.readStructBegin()
8712 
    while True:
8713 
      (fname, ftype, fid) = iprot.readFieldBegin()
8714 
      if ftype == TType.STOP:
8715 
        break
8716 
      if fid == 0:
8717 
        if ftype == TType.LIST:
8718 
          self.success = []
8590 kshitij.so 8719 
          (_etype56, _size53) = iprot.readListBegin()
8720 
          for _i57 in xrange(_size53):
8721 
            _elem58 = Item()
8722 
            _elem58.read(iprot)
8723 
            self.success.append(_elem58)
5944 mandeep.dh 8724 
          iprot.readListEnd()
8725 
        else:
8726 
          iprot.skip(ftype)
8727 
      elif fid == 1:
8728 
        if ftype == TType.STRUCT:
8729 
          self.cex = CatalogServiceException()
8730 
          self.cex.read(iprot)
8731 
        else:
8732 
          iprot.skip(ftype)
8733 
      else:
8734 
        iprot.skip(ftype)
8735 
      iprot.readFieldEnd()
8736 
    iprot.readStructEnd()
8737 
 
8738 
  def write(self, oprot):
8739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8741 
      return
8742 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8743 
    if self.success is not None:
8744 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8745 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8746 
      for iter59 in self.success:
8747 
        iter59.write(oprot)
5944 mandeep.dh 8748 
      oprot.writeListEnd()
8749 
      oprot.writeFieldEnd()
8750 
    if self.cex is not None:
8751 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8752 
      self.cex.write(oprot)
8753 
      oprot.writeFieldEnd()
8754 
    oprot.writeFieldStop()
8755 
    oprot.writeStructEnd()
8756 
 
8757 
  def validate(self):
8758 
    return
8759 
 
8760 
 
8761 
  def __repr__(self):
8762 
    L = ['%s=%r' % (key, value)
8763 
      for key, value in self.__dict__.iteritems()]
8764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8765 
 
8766 
  def __eq__(self, other):
8767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8768 
 
8769 
  def __ne__(self, other):
8770 
    return not (self == other)
8771 
 
8772 
class getAllItems_args:
8773 
  """
8774 
  Attributes:
8775 
   - isActive
8776 
  """
8777 
 
8778 
  thrift_spec = (
8779 
    None, # 0
8780 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8781 
  )
8782 
 
8783 
  def __init__(self, isActive=None,):
8784 
    self.isActive = isActive
8785 
 
8786 
  def read(self, iprot):
8787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8789 
      return
8790 
    iprot.readStructBegin()
8791 
    while True:
8792 
      (fname, ftype, fid) = iprot.readFieldBegin()
8793 
      if ftype == TType.STOP:
8794 
        break
8795 
      if fid == 1:
8796 
        if ftype == TType.BOOL:
8797 
          self.isActive = iprot.readBool();
8798 
        else:
8799 
          iprot.skip(ftype)
8800 
      else:
8801 
        iprot.skip(ftype)
8802 
      iprot.readFieldEnd()
8803 
    iprot.readStructEnd()
8804 
 
8805 
  def write(self, oprot):
8806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8808 
      return
8809 
    oprot.writeStructBegin('getAllItems_args')
8810 
    if self.isActive is not None:
8811 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8812 
      oprot.writeBool(self.isActive)
8813 
      oprot.writeFieldEnd()
8814 
    oprot.writeFieldStop()
8815 
    oprot.writeStructEnd()
8816 
 
8817 
  def validate(self):
8818 
    return
8819 
 
8820 
 
8821 
  def __repr__(self):
8822 
    L = ['%s=%r' % (key, value)
8823 
      for key, value in self.__dict__.iteritems()]
8824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8825 
 
8826 
  def __eq__(self, other):
8827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8828 
 
8829 
  def __ne__(self, other):
8830 
    return not (self == other)
8831 
 
8832 
class getAllItems_result:
8833 
  """
8834 
  Attributes:
8835 
   - success
8836 
   - cex
8837 
  """
8838 
 
8839 
  thrift_spec = (
8840 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8841 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8842 
  )
8843 
 
8844 
  def __init__(self, success=None, cex=None,):
8845 
    self.success = success
8846 
    self.cex = cex
8847 
 
8848 
  def read(self, iprot):
8849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8851 
      return
8852 
    iprot.readStructBegin()
8853 
    while True:
8854 
      (fname, ftype, fid) = iprot.readFieldBegin()
8855 
      if ftype == TType.STOP:
8856 
        break
8857 
      if fid == 0:
8858 
        if ftype == TType.LIST:
8859 
          self.success = []
8590 kshitij.so 8860 
          (_etype63, _size60) = iprot.readListBegin()
8861 
          for _i64 in xrange(_size60):
8862 
            _elem65 = Item()
8863 
            _elem65.read(iprot)
8864 
            self.success.append(_elem65)
5944 mandeep.dh 8865 
          iprot.readListEnd()
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      elif fid == 1:
8869 
        if ftype == TType.STRUCT:
8870 
          self.cex = CatalogServiceException()
8871 
          self.cex.read(iprot)
8872 
        else:
8873 
          iprot.skip(ftype)
8874 
      else:
8875 
        iprot.skip(ftype)
8876 
      iprot.readFieldEnd()
8877 
    iprot.readStructEnd()
8878 
 
8879 
  def write(self, oprot):
8880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8882 
      return
8883 
    oprot.writeStructBegin('getAllItems_result')
8884 
    if self.success is not None:
8885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8887 
      for iter66 in self.success:
8888 
        iter66.write(oprot)
5944 mandeep.dh 8889 
      oprot.writeListEnd()
8890 
      oprot.writeFieldEnd()
8891 
    if self.cex is not None:
8892 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8893 
      self.cex.write(oprot)
8894 
      oprot.writeFieldEnd()
8895 
    oprot.writeFieldStop()
8896 
    oprot.writeStructEnd()
8897 
 
8898 
  def validate(self):
8899 
    return
8900 
 
8901 
 
8902 
  def __repr__(self):
8903 
    L = ['%s=%r' % (key, value)
8904 
      for key, value in self.__dict__.iteritems()]
8905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8906 
 
8907 
  def __eq__(self, other):
8908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8909 
 
8910 
  def __ne__(self, other):
8911 
    return not (self == other)
8912 
 
8913 
class getAllItemsByStatus_args:
8914 
  """
8915 
  Attributes:
8916 
   - itemStatus
8917 
  """
8918 
 
8919 
  thrift_spec = (
8920 
    None, # 0
8921 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8922 
  )
8923 
 
8924 
  def __init__(self, itemStatus=None,):
8925 
    self.itemStatus = itemStatus
8926 
 
8927 
  def read(self, iprot):
8928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8930 
      return
8931 
    iprot.readStructBegin()
8932 
    while True:
8933 
      (fname, ftype, fid) = iprot.readFieldBegin()
8934 
      if ftype == TType.STOP:
8935 
        break
8936 
      if fid == 1:
8937 
        if ftype == TType.I32:
8938 
          self.itemStatus = iprot.readI32();
8939 
        else:
8940 
          iprot.skip(ftype)
8941 
      else:
8942 
        iprot.skip(ftype)
8943 
      iprot.readFieldEnd()
8944 
    iprot.readStructEnd()
8945 
 
8946 
  def write(self, oprot):
8947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8949 
      return
8950 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8951 
    if self.itemStatus is not None:
8952 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8953 
      oprot.writeI32(self.itemStatus)
8954 
      oprot.writeFieldEnd()
8955 
    oprot.writeFieldStop()
8956 
    oprot.writeStructEnd()
8957 
 
8958 
  def validate(self):
8959 
    return
8960 
 
8961 
 
8962 
  def __repr__(self):
8963 
    L = ['%s=%r' % (key, value)
8964 
      for key, value in self.__dict__.iteritems()]
8965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8966 
 
8967 
  def __eq__(self, other):
8968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8969 
 
8970 
  def __ne__(self, other):
8971 
    return not (self == other)
8972 
 
8973 
class getAllItemsByStatus_result:
8974 
  """
8975 
  Attributes:
8976 
   - success
8977 
   - cex
8978 
  """
8979 
 
8980 
  thrift_spec = (
8981 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8982 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8983 
  )
8984 
 
8985 
  def __init__(self, success=None, cex=None,):
8986 
    self.success = success
8987 
    self.cex = cex
8988 
 
8989 
  def read(self, iprot):
8990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8992 
      return
8993 
    iprot.readStructBegin()
8994 
    while True:
8995 
      (fname, ftype, fid) = iprot.readFieldBegin()
8996 
      if ftype == TType.STOP:
8997 
        break
8998 
      if fid == 0:
8999 
        if ftype == TType.LIST:
9000 
          self.success = []
8590 kshitij.so 9001 
          (_etype70, _size67) = iprot.readListBegin()
9002 
          for _i71 in xrange(_size67):
9003 
            _elem72 = Item()
9004 
            _elem72.read(iprot)
9005 
            self.success.append(_elem72)
5944 mandeep.dh 9006 
          iprot.readListEnd()
9007 
        else:
9008 
          iprot.skip(ftype)
9009 
      elif fid == 1:
9010 
        if ftype == TType.STRUCT:
9011 
          self.cex = CatalogServiceException()
9012 
          self.cex.read(iprot)
9013 
        else:
9014 
          iprot.skip(ftype)
9015 
      else:
9016 
        iprot.skip(ftype)
9017 
      iprot.readFieldEnd()
9018 
    iprot.readStructEnd()
9019 
 
9020 
  def write(self, oprot):
9021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9023 
      return
9024 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9025 
    if self.success is not None:
9026 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9027 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9028 
      for iter73 in self.success:
9029 
        iter73.write(oprot)
5944 mandeep.dh 9030 
      oprot.writeListEnd()
9031 
      oprot.writeFieldEnd()
9032 
    if self.cex is not None:
9033 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9034 
      self.cex.write(oprot)
9035 
      oprot.writeFieldEnd()
9036 
    oprot.writeFieldStop()
9037 
    oprot.writeStructEnd()
9038 
 
9039 
  def validate(self):
9040 
    return
9041 
 
9042 
 
9043 
  def __repr__(self):
9044 
    L = ['%s=%r' % (key, value)
9045 
      for key, value in self.__dict__.iteritems()]
9046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9047 
 
9048 
  def __eq__(self, other):
9049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9050 
 
9051 
  def __ne__(self, other):
9052 
    return not (self == other)
9053 
 
9054 
class markItemAsContentComplete_args:
9055 
  """
9056 
  Attributes:
9057 
   - entityId
9058 
   - category
9059 
   - brand
9060 
   - modelName
9061 
   - modelNumber
9253 rajveer 9062 
   - isAndroid
5944 mandeep.dh 9063 
  """
9064 
 
9065 
  thrift_spec = (
9066 
    None, # 0
9067 
    (1, TType.I64, 'entityId', None, None, ), # 1
9068 
    (2, TType.I64, 'category', None, None, ), # 2
9069 
    (3, TType.STRING, 'brand', None, None, ), # 3
9070 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9071 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9072 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9073 
  )
9074 
 
9253 rajveer 9075 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9076 
    self.entityId = entityId
9077 
    self.category = category
9078 
    self.brand = brand
9079 
    self.modelName = modelName
9080 
    self.modelNumber = modelNumber
9253 rajveer 9081 
    self.isAndroid = isAndroid
5944 mandeep.dh 9082 
 
9083 
  def read(self, iprot):
9084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9086 
      return
9087 
    iprot.readStructBegin()
9088 
    while True:
9089 
      (fname, ftype, fid) = iprot.readFieldBegin()
9090 
      if ftype == TType.STOP:
9091 
        break
9092 
      if fid == 1:
9093 
        if ftype == TType.I64:
9094 
          self.entityId = iprot.readI64();
9095 
        else:
9096 
          iprot.skip(ftype)
9097 
      elif fid == 2:
9098 
        if ftype == TType.I64:
9099 
          self.category = iprot.readI64();
9100 
        else:
9101 
          iprot.skip(ftype)
9102 
      elif fid == 3:
9103 
        if ftype == TType.STRING:
9104 
          self.brand = iprot.readString();
9105 
        else:
9106 
          iprot.skip(ftype)
9107 
      elif fid == 4:
9108 
        if ftype == TType.STRING:
9109 
          self.modelName = iprot.readString();
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      elif fid == 5:
9113 
        if ftype == TType.STRING:
9114 
          self.modelNumber = iprot.readString();
9115 
        else:
9116 
          iprot.skip(ftype)
9253 rajveer 9117 
      elif fid == 6:
9118 
        if ftype == TType.BOOL:
9119 
          self.isAndroid = iprot.readBool();
9120 
        else:
9121 
          iprot.skip(ftype)
5944 mandeep.dh 9122 
      else:
9123 
        iprot.skip(ftype)
9124 
      iprot.readFieldEnd()
9125 
    iprot.readStructEnd()
9126 
 
9127 
  def write(self, oprot):
9128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9130 
      return
9131 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9132 
    if self.entityId is not None:
9133 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9134 
      oprot.writeI64(self.entityId)
9135 
      oprot.writeFieldEnd()
9136 
    if self.category is not None:
9137 
      oprot.writeFieldBegin('category', TType.I64, 2)
9138 
      oprot.writeI64(self.category)
9139 
      oprot.writeFieldEnd()
9140 
    if self.brand is not None:
9141 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9142 
      oprot.writeString(self.brand)
9143 
      oprot.writeFieldEnd()
9144 
    if self.modelName is not None:
9145 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9146 
      oprot.writeString(self.modelName)
9147 
      oprot.writeFieldEnd()
9148 
    if self.modelNumber is not None:
9149 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9150 
      oprot.writeString(self.modelNumber)
9151 
      oprot.writeFieldEnd()
9253 rajveer 9152 
    if self.isAndroid is not None:
9153 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9154 
      oprot.writeBool(self.isAndroid)
9155 
      oprot.writeFieldEnd()
5944 mandeep.dh 9156 
    oprot.writeFieldStop()
9157 
    oprot.writeStructEnd()
9158 
 
9159 
  def validate(self):
9160 
    return
9161 
 
9162 
 
9163 
  def __repr__(self):
9164 
    L = ['%s=%r' % (key, value)
9165 
      for key, value in self.__dict__.iteritems()]
9166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9167 
 
9168 
  def __eq__(self, other):
9169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9170 
 
9171 
  def __ne__(self, other):
9172 
    return not (self == other)
9173 
 
9174 
class markItemAsContentComplete_result:
9175 
  """
9176 
  Attributes:
9177 
   - success
9178 
   - cex
9179 
  """
9180 
 
9181 
  thrift_spec = (
9182 
    (0, TType.BOOL, 'success', None, None, ), # 0
9183 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9184 
  )
9185 
 
9186 
  def __init__(self, success=None, cex=None,):
9187 
    self.success = success
9188 
    self.cex = cex
9189 
 
9190 
  def read(self, iprot):
9191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9193 
      return
9194 
    iprot.readStructBegin()
9195 
    while True:
9196 
      (fname, ftype, fid) = iprot.readFieldBegin()
9197 
      if ftype == TType.STOP:
9198 
        break
9199 
      if fid == 0:
9200 
        if ftype == TType.BOOL:
9201 
          self.success = iprot.readBool();
9202 
        else:
9203 
          iprot.skip(ftype)
9204 
      elif fid == 1:
9205 
        if ftype == TType.STRUCT:
9206 
          self.cex = CatalogServiceException()
9207 
          self.cex.read(iprot)
9208 
        else:
9209 
          iprot.skip(ftype)
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9220 
    if self.success is not None:
9221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9222 
      oprot.writeBool(self.success)
9223 
      oprot.writeFieldEnd()
9224 
    if self.cex is not None:
9225 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9226 
      self.cex.write(oprot)
9227 
      oprot.writeFieldEnd()
9228 
    oprot.writeFieldStop()
9229 
    oprot.writeStructEnd()
9230 
 
9231 
  def validate(self):
9232 
    return
9233 
 
9234 
 
9235 
  def __repr__(self):
9236 
    L = ['%s=%r' % (key, value)
9237 
      for key, value in self.__dict__.iteritems()]
9238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9239 
 
9240 
  def __eq__(self, other):
9241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9242 
 
9243 
  def __ne__(self, other):
9244 
    return not (self == other)
9245 
 
9246 
class getAllItemsInRange_args:
9247 
  """
9248 
  Attributes:
9249 
   - offset
9250 
   - limit
9251 
  """
9252 
 
9253 
  thrift_spec = (
9254 
    None, # 0
9255 
    (1, TType.I64, 'offset', None, None, ), # 1
9256 
    (2, TType.I64, 'limit', None, None, ), # 2
9257 
  )
9258 
 
9259 
  def __init__(self, offset=None, limit=None,):
9260 
    self.offset = offset
9261 
    self.limit = limit
9262 
 
9263 
  def read(self, iprot):
9264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9266 
      return
9267 
    iprot.readStructBegin()
9268 
    while True:
9269 
      (fname, ftype, fid) = iprot.readFieldBegin()
9270 
      if ftype == TType.STOP:
9271 
        break
9272 
      if fid == 1:
9273 
        if ftype == TType.I64:
9274 
          self.offset = iprot.readI64();
9275 
        else:
9276 
          iprot.skip(ftype)
9277 
      elif fid == 2:
9278 
        if ftype == TType.I64:
9279 
          self.limit = iprot.readI64();
9280 
        else:
9281 
          iprot.skip(ftype)
9282 
      else:
9283 
        iprot.skip(ftype)
9284 
      iprot.readFieldEnd()
9285 
    iprot.readStructEnd()
9286 
 
9287 
  def write(self, oprot):
9288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9290 
      return
9291 
    oprot.writeStructBegin('getAllItemsInRange_args')
9292 
    if self.offset is not None:
9293 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9294 
      oprot.writeI64(self.offset)
9295 
      oprot.writeFieldEnd()
9296 
    if self.limit is not None:
9297 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9298 
      oprot.writeI64(self.limit)
9299 
      oprot.writeFieldEnd()
9300 
    oprot.writeFieldStop()
9301 
    oprot.writeStructEnd()
9302 
 
9303 
  def validate(self):
9304 
    return
9305 
 
9306 
 
9307 
  def __repr__(self):
9308 
    L = ['%s=%r' % (key, value)
9309 
      for key, value in self.__dict__.iteritems()]
9310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9311 
 
9312 
  def __eq__(self, other):
9313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9314 
 
9315 
  def __ne__(self, other):
9316 
    return not (self == other)
9317 
 
9318 
class getAllItemsInRange_result:
9319 
  """
9320 
  Attributes:
9321 
   - success
9322 
   - cex
9323 
  """
9324 
 
9325 
  thrift_spec = (
9326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9327 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9328 
  )
9329 
 
9330 
  def __init__(self, success=None, cex=None,):
9331 
    self.success = success
9332 
    self.cex = cex
9333 
 
9334 
  def read(self, iprot):
9335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9337 
      return
9338 
    iprot.readStructBegin()
9339 
    while True:
9340 
      (fname, ftype, fid) = iprot.readFieldBegin()
9341 
      if ftype == TType.STOP:
9342 
        break
9343 
      if fid == 0:
9344 
        if ftype == TType.LIST:
9345 
          self.success = []
8590 kshitij.so 9346 
          (_etype77, _size74) = iprot.readListBegin()
9347 
          for _i78 in xrange(_size74):
9348 
            _elem79 = Item()
9349 
            _elem79.read(iprot)
9350 
            self.success.append(_elem79)
5944 mandeep.dh 9351 
          iprot.readListEnd()
9352 
        else:
9353 
          iprot.skip(ftype)
9354 
      elif fid == 1:
9355 
        if ftype == TType.STRUCT:
9356 
          self.cex = CatalogServiceException()
9357 
          self.cex.read(iprot)
9358 
        else:
9359 
          iprot.skip(ftype)
9360 
      else:
9361 
        iprot.skip(ftype)
9362 
      iprot.readFieldEnd()
9363 
    iprot.readStructEnd()
9364 
 
9365 
  def write(self, oprot):
9366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9368 
      return
9369 
    oprot.writeStructBegin('getAllItemsInRange_result')
9370 
    if self.success is not None:
9371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9373 
      for iter80 in self.success:
9374 
        iter80.write(oprot)
5944 mandeep.dh 9375 
      oprot.writeListEnd()
9376 
      oprot.writeFieldEnd()
9377 
    if self.cex is not None:
9378 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9379 
      self.cex.write(oprot)
9380 
      oprot.writeFieldEnd()
9381 
    oprot.writeFieldStop()
9382 
    oprot.writeStructEnd()
9383 
 
9384 
  def validate(self):
9385 
    return
9386 
 
9387 
 
9388 
  def __repr__(self):
9389 
    L = ['%s=%r' % (key, value)
9390 
      for key, value in self.__dict__.iteritems()]
9391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9392 
 
9393 
  def __eq__(self, other):
9394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9395 
 
9396 
  def __ne__(self, other):
9397 
    return not (self == other)
9398 
 
9399 
class getAllItemsByStatusInRange_args:
9400 
  """
9401 
  Attributes:
9402 
   - itemStatus
9403 
   - offset
9404 
   - limit
9405 
  """
9406 
 
9407 
  thrift_spec = (
9408 
    None, # 0
9409 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9410 
    (2, TType.I64, 'offset', None, None, ), # 2
9411 
    (3, TType.I64, 'limit', None, None, ), # 3
9412 
  )
9413 
 
9414 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9415 
    self.itemStatus = itemStatus
9416 
    self.offset = offset
9417 
    self.limit = limit
9418 
 
9419 
  def read(self, iprot):
9420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9422 
      return
9423 
    iprot.readStructBegin()
9424 
    while True:
9425 
      (fname, ftype, fid) = iprot.readFieldBegin()
9426 
      if ftype == TType.STOP:
9427 
        break
9428 
      if fid == 1:
9429 
        if ftype == TType.I32:
9430 
          self.itemStatus = iprot.readI32();
9431 
        else:
9432 
          iprot.skip(ftype)
9433 
      elif fid == 2:
9434 
        if ftype == TType.I64:
9435 
          self.offset = iprot.readI64();
9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      elif fid == 3:
9439 
        if ftype == TType.I64:
9440 
          self.limit = iprot.readI64();
9441 
        else:
9442 
          iprot.skip(ftype)
9443 
      else:
9444 
        iprot.skip(ftype)
9445 
      iprot.readFieldEnd()
9446 
    iprot.readStructEnd()
9447 
 
9448 
  def write(self, oprot):
9449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9451 
      return
9452 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9453 
    if self.itemStatus is not None:
9454 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9455 
      oprot.writeI32(self.itemStatus)
9456 
      oprot.writeFieldEnd()
9457 
    if self.offset is not None:
9458 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9459 
      oprot.writeI64(self.offset)
9460 
      oprot.writeFieldEnd()
9461 
    if self.limit is not None:
9462 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9463 
      oprot.writeI64(self.limit)
9464 
      oprot.writeFieldEnd()
9465 
    oprot.writeFieldStop()
9466 
    oprot.writeStructEnd()
9467 
 
9468 
  def validate(self):
9469 
    return
9470 
 
9471 
 
9472 
  def __repr__(self):
9473 
    L = ['%s=%r' % (key, value)
9474 
      for key, value in self.__dict__.iteritems()]
9475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9476 
 
9477 
  def __eq__(self, other):
9478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9479 
 
9480 
  def __ne__(self, other):
9481 
    return not (self == other)
9482 
 
9483 
class getAllItemsByStatusInRange_result:
9484 
  """
9485 
  Attributes:
9486 
   - success
9487 
   - cex
9488 
  """
9489 
 
9490 
  thrift_spec = (
9491 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9492 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9493 
  )
9494 
 
9495 
  def __init__(self, success=None, cex=None,):
9496 
    self.success = success
9497 
    self.cex = cex
9498 
 
9499 
  def read(self, iprot):
9500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9502 
      return
9503 
    iprot.readStructBegin()
9504 
    while True:
9505 
      (fname, ftype, fid) = iprot.readFieldBegin()
9506 
      if ftype == TType.STOP:
9507 
        break
9508 
      if fid == 0:
9509 
        if ftype == TType.LIST:
9510 
          self.success = []
8590 kshitij.so 9511 
          (_etype84, _size81) = iprot.readListBegin()
9512 
          for _i85 in xrange(_size81):
9513 
            _elem86 = Item()
9514 
            _elem86.read(iprot)
9515 
            self.success.append(_elem86)
5944 mandeep.dh 9516 
          iprot.readListEnd()
9517 
        else:
9518 
          iprot.skip(ftype)
9519 
      elif fid == 1:
9520 
        if ftype == TType.STRUCT:
9521 
          self.cex = CatalogServiceException()
9522 
          self.cex.read(iprot)
9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
9534 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9535 
    if self.success is not None:
9536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9538 
      for iter87 in self.success:
9539 
        iter87.write(oprot)
5944 mandeep.dh 9540 
      oprot.writeListEnd()
9541 
      oprot.writeFieldEnd()
9542 
    if self.cex is not None:
9543 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9544 
      self.cex.write(oprot)
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
9564 
class getItemCountByStatus_args:
9565 
  """
9566 
  Attributes:
9567 
   - useStatus
9568 
   - itemStatus
9569 
  """
9570 
 
9571 
  thrift_spec = (
9572 
    None, # 0
9573 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9574 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9575 
  )
9576 
 
9577 
  def __init__(self, useStatus=None, itemStatus=None,):
9578 
    self.useStatus = useStatus
9579 
    self.itemStatus = itemStatus
9580 
 
9581 
  def read(self, iprot):
9582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9584 
      return
9585 
    iprot.readStructBegin()
9586 
    while True:
9587 
      (fname, ftype, fid) = iprot.readFieldBegin()
9588 
      if ftype == TType.STOP:
9589 
        break
9590 
      if fid == 1:
9591 
        if ftype == TType.BOOL:
9592 
          self.useStatus = iprot.readBool();
9593 
        else:
9594 
          iprot.skip(ftype)
9595 
      elif fid == 2:
9596 
        if ftype == TType.I32:
9597 
          self.itemStatus = iprot.readI32();
9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      else:
9601 
        iprot.skip(ftype)
9602 
      iprot.readFieldEnd()
9603 
    iprot.readStructEnd()
9604 
 
9605 
  def write(self, oprot):
9606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9608 
      return
9609 
    oprot.writeStructBegin('getItemCountByStatus_args')
9610 
    if self.useStatus is not None:
9611 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9612 
      oprot.writeBool(self.useStatus)
9613 
      oprot.writeFieldEnd()
9614 
    if self.itemStatus is not None:
9615 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9616 
      oprot.writeI32(self.itemStatus)
9617 
      oprot.writeFieldEnd()
9618 
    oprot.writeFieldStop()
9619 
    oprot.writeStructEnd()
9620 
 
9621 
  def validate(self):
9622 
    return
9623 
 
9624 
 
9625 
  def __repr__(self):
9626 
    L = ['%s=%r' % (key, value)
9627 
      for key, value in self.__dict__.iteritems()]
9628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9629 
 
9630 
  def __eq__(self, other):
9631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9632 
 
9633 
  def __ne__(self, other):
9634 
    return not (self == other)
9635 
 
9636 
class getItemCountByStatus_result:
9637 
  """
9638 
  Attributes:
9639 
   - success
9640 
  """
9641 
 
9642 
  thrift_spec = (
9643 
    (0, TType.I32, 'success', None, None, ), # 0
9644 
  )
9645 
 
9646 
  def __init__(self, success=None,):
9647 
    self.success = success
9648 
 
9649 
  def read(self, iprot):
9650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9652 
      return
9653 
    iprot.readStructBegin()
9654 
    while True:
9655 
      (fname, ftype, fid) = iprot.readFieldBegin()
9656 
      if ftype == TType.STOP:
9657 
        break
9658 
      if fid == 0:
9659 
        if ftype == TType.I32:
9660 
          self.success = iprot.readI32();
9661 
        else:
9662 
          iprot.skip(ftype)
9663 
      else:
9664 
        iprot.skip(ftype)
9665 
      iprot.readFieldEnd()
9666 
    iprot.readStructEnd()
9667 
 
9668 
  def write(self, oprot):
9669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9671 
      return
9672 
    oprot.writeStructBegin('getItemCountByStatus_result')
9673 
    if self.success is not None:
9674 
      oprot.writeFieldBegin('success', TType.I32, 0)
9675 
      oprot.writeI32(self.success)
9676 
      oprot.writeFieldEnd()
9677 
    oprot.writeFieldStop()
9678 
    oprot.writeStructEnd()
9679 
 
9680 
  def validate(self):
9681 
    return
9682 
 
9683 
 
9684 
  def __repr__(self):
9685 
    L = ['%s=%r' % (key, value)
9686 
      for key, value in self.__dict__.iteritems()]
9687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9688 
 
9689 
  def __eq__(self, other):
9690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9691 
 
9692 
  def __ne__(self, other):
9693 
    return not (self == other)
9694 
 
9695 
class getBestSellers_args:
9696 
 
9697 
  thrift_spec = (
9698 
  )
9699 
 
9700 
  def read(self, iprot):
9701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9703 
      return
9704 
    iprot.readStructBegin()
9705 
    while True:
9706 
      (fname, ftype, fid) = iprot.readFieldBegin()
9707 
      if ftype == TType.STOP:
9708 
        break
9709 
      else:
9710 
        iprot.skip(ftype)
9711 
      iprot.readFieldEnd()
9712 
    iprot.readStructEnd()
9713 
 
9714 
  def write(self, oprot):
9715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9717 
      return
9718 
    oprot.writeStructBegin('getBestSellers_args')
9719 
    oprot.writeFieldStop()
9720 
    oprot.writeStructEnd()
9721 
 
9722 
  def validate(self):
9723 
    return
9724 
 
9725 
 
9726 
  def __repr__(self):
9727 
    L = ['%s=%r' % (key, value)
9728 
      for key, value in self.__dict__.iteritems()]
9729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9730 
 
9731 
  def __eq__(self, other):
9732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9733 
 
9734 
  def __ne__(self, other):
9735 
    return not (self == other)
9736 
 
9737 
class getBestSellers_result:
9738 
  """
9739 
  Attributes:
9740 
   - success
9741 
   - isex
9742 
  """
9743 
 
9744 
  thrift_spec = (
9745 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9746 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9747 
  )
9748 
 
9749 
  def __init__(self, success=None, isex=None,):
9750 
    self.success = success
9751 
    self.isex = isex
9752 
 
9753 
  def read(self, iprot):
9754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9756 
      return
9757 
    iprot.readStructBegin()
9758 
    while True:
9759 
      (fname, ftype, fid) = iprot.readFieldBegin()
9760 
      if ftype == TType.STOP:
9761 
        break
9762 
      if fid == 0:
9763 
        if ftype == TType.LIST:
9764 
          self.success = []
8590 kshitij.so 9765 
          (_etype91, _size88) = iprot.readListBegin()
9766 
          for _i92 in xrange(_size88):
9767 
            _elem93 = Item()
9768 
            _elem93.read(iprot)
9769 
            self.success.append(_elem93)
5944 mandeep.dh 9770 
          iprot.readListEnd()
9771 
        else:
9772 
          iprot.skip(ftype)
9773 
      elif fid == 1:
9774 
        if ftype == TType.STRUCT:
9775 
          self.isex = CatalogServiceException()
9776 
          self.isex.read(iprot)
9777 
        else:
9778 
          iprot.skip(ftype)
9779 
      else:
9780 
        iprot.skip(ftype)
9781 
      iprot.readFieldEnd()
9782 
    iprot.readStructEnd()
9783 
 
9784 
  def write(self, oprot):
9785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9787 
      return
9788 
    oprot.writeStructBegin('getBestSellers_result')
9789 
    if self.success is not None:
9790 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9791 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9792 
      for iter94 in self.success:
9793 
        iter94.write(oprot)
5944 mandeep.dh 9794 
      oprot.writeListEnd()
9795 
      oprot.writeFieldEnd()
9796 
    if self.isex is not None:
9797 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9798 
      self.isex.write(oprot)
9799 
      oprot.writeFieldEnd()
9800 
    oprot.writeFieldStop()
9801 
    oprot.writeStructEnd()
9802 
 
9803 
  def validate(self):
9804 
    return
9805 
 
9806 
 
9807 
  def __repr__(self):
9808 
    L = ['%s=%r' % (key, value)
9809 
      for key, value in self.__dict__.iteritems()]
9810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9811 
 
9812 
  def __eq__(self, other):
9813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9814 
 
9815 
  def __ne__(self, other):
9816 
    return not (self == other)
9817 
 
9818 
class getBestSellersCatalogIds_args:
9819 
  """
9820 
  Attributes:
9821 
   - beginIndex
9822 
   - totalItems
9823 
   - brand
9824 
   - category
9825 
  """
9826 
 
9827 
  thrift_spec = (
9828 
    None, # 0
9829 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9830 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9831 
    (3, TType.STRING, 'brand', None, None, ), # 3
9832 
    (4, TType.I64, 'category', None, None, ), # 4
9833 
  )
9834 
 
9835 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9836 
    self.beginIndex = beginIndex
9837 
    self.totalItems = totalItems
9838 
    self.brand = brand
9839 
    self.category = category
9840 
 
9841 
  def read(self, iprot):
9842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9844 
      return
9845 
    iprot.readStructBegin()
9846 
    while True:
9847 
      (fname, ftype, fid) = iprot.readFieldBegin()
9848 
      if ftype == TType.STOP:
9849 
        break
9850 
      if fid == 1:
9851 
        if ftype == TType.I64:
9852 
          self.beginIndex = iprot.readI64();
9853 
        else:
9854 
          iprot.skip(ftype)
9855 
      elif fid == 2:
9856 
        if ftype == TType.I64:
9857 
          self.totalItems = iprot.readI64();
9858 
        else:
9859 
          iprot.skip(ftype)
9860 
      elif fid == 3:
9861 
        if ftype == TType.STRING:
9862 
          self.brand = iprot.readString();
9863 
        else:
9864 
          iprot.skip(ftype)
9865 
      elif fid == 4:
9866 
        if ftype == TType.I64:
9867 
          self.category = iprot.readI64();
9868 
        else:
9869 
          iprot.skip(ftype)
9870 
      else:
9871 
        iprot.skip(ftype)
9872 
      iprot.readFieldEnd()
9873 
    iprot.readStructEnd()
9874 
 
9875 
  def write(self, oprot):
9876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9878 
      return
9879 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9880 
    if self.beginIndex is not None:
9881 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9882 
      oprot.writeI64(self.beginIndex)
9883 
      oprot.writeFieldEnd()
9884 
    if self.totalItems is not None:
9885 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9886 
      oprot.writeI64(self.totalItems)
9887 
      oprot.writeFieldEnd()
9888 
    if self.brand is not None:
9889 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9890 
      oprot.writeString(self.brand)
9891 
      oprot.writeFieldEnd()
9892 
    if self.category is not None:
9893 
      oprot.writeFieldBegin('category', TType.I64, 4)
9894 
      oprot.writeI64(self.category)
9895 
      oprot.writeFieldEnd()
9896 
    oprot.writeFieldStop()
9897 
    oprot.writeStructEnd()
9898 
 
9899 
  def validate(self):
9900 
    return
9901 
 
9902 
 
9903 
  def __repr__(self):
9904 
    L = ['%s=%r' % (key, value)
9905 
      for key, value in self.__dict__.iteritems()]
9906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9907 
 
9908 
  def __eq__(self, other):
9909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9910 
 
9911 
  def __ne__(self, other):
9912 
    return not (self == other)
9913 
 
9914 
class getBestSellersCatalogIds_result:
9915 
  """
9916 
  Attributes:
9917 
   - success
9918 
   - cex
9919 
  """
9920 
 
9921 
  thrift_spec = (
9922 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9923 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9924 
  )
9925 
 
9926 
  def __init__(self, success=None, cex=None,):
9927 
    self.success = success
9928 
    self.cex = cex
9929 
 
9930 
  def read(self, iprot):
9931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9933 
      return
9934 
    iprot.readStructBegin()
9935 
    while True:
9936 
      (fname, ftype, fid) = iprot.readFieldBegin()
9937 
      if ftype == TType.STOP:
9938 
        break
9939 
      if fid == 0:
9940 
        if ftype == TType.LIST:
9941 
          self.success = []
8590 kshitij.so 9942 
          (_etype98, _size95) = iprot.readListBegin()
9943 
          for _i99 in xrange(_size95):
9944 
            _elem100 = iprot.readI64();
9945 
            self.success.append(_elem100)
5944 mandeep.dh 9946 
          iprot.readListEnd()
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 1:
9950 
        if ftype == TType.STRUCT:
9951 
          self.cex = CatalogServiceException()
9952 
          self.cex.read(iprot)
9953 
        else:
9954 
          iprot.skip(ftype)
9955 
      else:
9956 
        iprot.skip(ftype)
9957 
      iprot.readFieldEnd()
9958 
    iprot.readStructEnd()
9959 
 
9960 
  def write(self, oprot):
9961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9963 
      return
9964 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9965 
    if self.success is not None:
9966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9967 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9968 
      for iter101 in self.success:
9969 
        oprot.writeI64(iter101)
5944 mandeep.dh 9970 
      oprot.writeListEnd()
9971 
      oprot.writeFieldEnd()
9972 
    if self.cex is not None:
9973 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9974 
      self.cex.write(oprot)
9975 
      oprot.writeFieldEnd()
9976 
    oprot.writeFieldStop()
9977 
    oprot.writeStructEnd()
9978 
 
9979 
  def validate(self):
9980 
    return
9981 
 
9982 
 
9983 
  def __repr__(self):
9984 
    L = ['%s=%r' % (key, value)
9985 
      for key, value in self.__dict__.iteritems()]
9986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9987 
 
9988 
  def __eq__(self, other):
9989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9990 
 
9991 
  def __ne__(self, other):
9992 
    return not (self == other)
9993 
 
9994 
class getBestSellersCount_args:
9995 
 
9996 
  thrift_spec = (
9997 
  )
9998 
 
9999 
  def read(self, iprot):
10000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10002 
      return
10003 
    iprot.readStructBegin()
10004 
    while True:
10005 
      (fname, ftype, fid) = iprot.readFieldBegin()
10006 
      if ftype == TType.STOP:
10007 
        break
10008 
      else:
10009 
        iprot.skip(ftype)
10010 
      iprot.readFieldEnd()
10011 
    iprot.readStructEnd()
10012 
 
10013 
  def write(self, oprot):
10014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10016 
      return
10017 
    oprot.writeStructBegin('getBestSellersCount_args')
10018 
    oprot.writeFieldStop()
10019 
    oprot.writeStructEnd()
10020 
 
10021 
  def validate(self):
10022 
    return
10023 
 
10024 
 
10025 
  def __repr__(self):
10026 
    L = ['%s=%r' % (key, value)
10027 
      for key, value in self.__dict__.iteritems()]
10028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10029 
 
10030 
  def __eq__(self, other):
10031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10032 
 
10033 
  def __ne__(self, other):
10034 
    return not (self == other)
10035 
 
10036 
class getBestSellersCount_result:
10037 
  """
10038 
  Attributes:
10039 
   - success
10040 
   - cex
10041 
  """
10042 
 
10043 
  thrift_spec = (
10044 
    (0, TType.I64, 'success', None, None, ), # 0
10045 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10046 
  )
10047 
 
10048 
  def __init__(self, success=None, cex=None,):
10049 
    self.success = success
10050 
    self.cex = cex
10051 
 
10052 
  def read(self, iprot):
10053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10055 
      return
10056 
    iprot.readStructBegin()
10057 
    while True:
10058 
      (fname, ftype, fid) = iprot.readFieldBegin()
10059 
      if ftype == TType.STOP:
10060 
        break
10061 
      if fid == 0:
10062 
        if ftype == TType.I64:
10063 
          self.success = iprot.readI64();
10064 
        else:
10065 
          iprot.skip(ftype)
10066 
      elif fid == 1:
10067 
        if ftype == TType.STRUCT:
10068 
          self.cex = CatalogServiceException()
10069 
          self.cex.read(iprot)
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      else:
10073 
        iprot.skip(ftype)
10074 
      iprot.readFieldEnd()
10075 
    iprot.readStructEnd()
10076 
 
10077 
  def write(self, oprot):
10078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10080 
      return
10081 
    oprot.writeStructBegin('getBestSellersCount_result')
10082 
    if self.success is not None:
10083 
      oprot.writeFieldBegin('success', TType.I64, 0)
10084 
      oprot.writeI64(self.success)
10085 
      oprot.writeFieldEnd()
10086 
    if self.cex is not None:
10087 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10088 
      self.cex.write(oprot)
10089 
      oprot.writeFieldEnd()
10090 
    oprot.writeFieldStop()
10091 
    oprot.writeStructEnd()
10092 
 
10093 
  def validate(self):
10094 
    return
10095 
 
10096 
 
10097 
  def __repr__(self):
10098 
    L = ['%s=%r' % (key, value)
10099 
      for key, value in self.__dict__.iteritems()]
10100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10101 
 
10102 
  def __eq__(self, other):
10103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10104 
 
10105 
  def __ne__(self, other):
10106 
    return not (self == other)
10107 
 
10108 
class getBestDeals_args:
10109 
 
10110 
  thrift_spec = (
10111 
  )
10112 
 
10113 
  def read(self, iprot):
10114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10116 
      return
10117 
    iprot.readStructBegin()
10118 
    while True:
10119 
      (fname, ftype, fid) = iprot.readFieldBegin()
10120 
      if ftype == TType.STOP:
10121 
        break
10122 
      else:
10123 
        iprot.skip(ftype)
10124 
      iprot.readFieldEnd()
10125 
    iprot.readStructEnd()
10126 
 
10127 
  def write(self, oprot):
10128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10130 
      return
10131 
    oprot.writeStructBegin('getBestDeals_args')
10132 
    oprot.writeFieldStop()
10133 
    oprot.writeStructEnd()
10134 
 
10135 
  def validate(self):
10136 
    return
10137 
 
10138 
 
10139 
  def __repr__(self):
10140 
    L = ['%s=%r' % (key, value)
10141 
      for key, value in self.__dict__.iteritems()]
10142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10143 
 
10144 
  def __eq__(self, other):
10145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10146 
 
10147 
  def __ne__(self, other):
10148 
    return not (self == other)
10149 
 
10150 
class getBestDeals_result:
10151 
  """
10152 
  Attributes:
10153 
   - success
10154 
   - isex
10155 
  """
10156 
 
10157 
  thrift_spec = (
10158 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10159 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10160 
  )
10161 
 
10162 
  def __init__(self, success=None, isex=None,):
10163 
    self.success = success
10164 
    self.isex = isex
10165 
 
10166 
  def read(self, iprot):
10167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10169 
      return
10170 
    iprot.readStructBegin()
10171 
    while True:
10172 
      (fname, ftype, fid) = iprot.readFieldBegin()
10173 
      if ftype == TType.STOP:
10174 
        break
10175 
      if fid == 0:
10176 
        if ftype == TType.LIST:
10177 
          self.success = []
8590 kshitij.so 10178 
          (_etype105, _size102) = iprot.readListBegin()
10179 
          for _i106 in xrange(_size102):
10180 
            _elem107 = Item()
10181 
            _elem107.read(iprot)
10182 
            self.success.append(_elem107)
5944 mandeep.dh 10183 
          iprot.readListEnd()
10184 
        else:
10185 
          iprot.skip(ftype)
10186 
      elif fid == 1:
10187 
        if ftype == TType.STRUCT:
10188 
          self.isex = CatalogServiceException()
10189 
          self.isex.read(iprot)
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('getBestDeals_result')
10202 
    if self.success is not None:
10203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10204 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10205 
      for iter108 in self.success:
10206 
        iter108.write(oprot)
5944 mandeep.dh 10207 
      oprot.writeListEnd()
10208 
      oprot.writeFieldEnd()
10209 
    if self.isex is not None:
10210 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10211 
      self.isex.write(oprot)
10212 
      oprot.writeFieldEnd()
10213 
    oprot.writeFieldStop()
10214 
    oprot.writeStructEnd()
10215 
 
10216 
  def validate(self):
10217 
    return
10218 
 
10219 
 
10220 
  def __repr__(self):
10221 
    L = ['%s=%r' % (key, value)
10222 
      for key, value in self.__dict__.iteritems()]
10223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10224 
 
10225 
  def __eq__(self, other):
10226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10227 
 
10228 
  def __ne__(self, other):
10229 
    return not (self == other)
10230 
 
10231 
class getBestDealsCatalogIds_args:
10232 
  """
10233 
  Attributes:
10234 
   - beginIndex
10235 
   - totalItems
10236 
   - brand
10237 
   - category
10238 
  """
10239 
 
10240 
  thrift_spec = (
10241 
    None, # 0
10242 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10243 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10244 
    (3, TType.STRING, 'brand', None, None, ), # 3
10245 
    (4, TType.I64, 'category', None, None, ), # 4
10246 
  )
10247 
 
10248 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10249 
    self.beginIndex = beginIndex
10250 
    self.totalItems = totalItems
10251 
    self.brand = brand
10252 
    self.category = category
10253 
 
10254 
  def read(self, iprot):
10255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10257 
      return
10258 
    iprot.readStructBegin()
10259 
    while True:
10260 
      (fname, ftype, fid) = iprot.readFieldBegin()
10261 
      if ftype == TType.STOP:
10262 
        break
10263 
      if fid == 1:
10264 
        if ftype == TType.I64:
10265 
          self.beginIndex = iprot.readI64();
10266 
        else:
10267 
          iprot.skip(ftype)
10268 
      elif fid == 2:
10269 
        if ftype == TType.I64:
10270 
          self.totalItems = iprot.readI64();
10271 
        else:
10272 
          iprot.skip(ftype)
10273 
      elif fid == 3:
10274 
        if ftype == TType.STRING:
10275 
          self.brand = iprot.readString();
10276 
        else:
10277 
          iprot.skip(ftype)
10278 
      elif fid == 4:
10279 
        if ftype == TType.I64:
10280 
          self.category = iprot.readI64();
10281 
        else:
10282 
          iprot.skip(ftype)
10283 
      else:
10284 
        iprot.skip(ftype)
10285 
      iprot.readFieldEnd()
10286 
    iprot.readStructEnd()
10287 
 
10288 
  def write(self, oprot):
10289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10291 
      return
10292 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10293 
    if self.beginIndex is not None:
10294 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10295 
      oprot.writeI64(self.beginIndex)
10296 
      oprot.writeFieldEnd()
10297 
    if self.totalItems is not None:
10298 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10299 
      oprot.writeI64(self.totalItems)
10300 
      oprot.writeFieldEnd()
10301 
    if self.brand is not None:
10302 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10303 
      oprot.writeString(self.brand)
10304 
      oprot.writeFieldEnd()
10305 
    if self.category is not None:
10306 
      oprot.writeFieldBegin('category', TType.I64, 4)
10307 
      oprot.writeI64(self.category)
10308 
      oprot.writeFieldEnd()
10309 
    oprot.writeFieldStop()
10310 
    oprot.writeStructEnd()
10311 
 
10312 
  def validate(self):
10313 
    return
10314 
 
10315 
 
10316 
  def __repr__(self):
10317 
    L = ['%s=%r' % (key, value)
10318 
      for key, value in self.__dict__.iteritems()]
10319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10320 
 
10321 
  def __eq__(self, other):
10322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10323 
 
10324 
  def __ne__(self, other):
10325 
    return not (self == other)
10326 
 
10327 
class getBestDealsCatalogIds_result:
10328 
  """
10329 
  Attributes:
10330 
   - success
10331 
   - cex
10332 
  """
10333 
 
10334 
  thrift_spec = (
10335 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10336 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10337 
  )
10338 
 
10339 
  def __init__(self, success=None, cex=None,):
10340 
    self.success = success
10341 
    self.cex = cex
10342 
 
10343 
  def read(self, iprot):
10344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10346 
      return
10347 
    iprot.readStructBegin()
10348 
    while True:
10349 
      (fname, ftype, fid) = iprot.readFieldBegin()
10350 
      if ftype == TType.STOP:
10351 
        break
10352 
      if fid == 0:
10353 
        if ftype == TType.LIST:
10354 
          self.success = []
8590 kshitij.so 10355 
          (_etype112, _size109) = iprot.readListBegin()
10356 
          for _i113 in xrange(_size109):
10357 
            _elem114 = iprot.readI64();
10358 
            self.success.append(_elem114)
5944 mandeep.dh 10359 
          iprot.readListEnd()
10360 
        else:
10361 
          iprot.skip(ftype)
10362 
      elif fid == 1:
10363 
        if ftype == TType.STRUCT:
10364 
          self.cex = CatalogServiceException()
10365 
          self.cex.read(iprot)
10366 
        else:
10367 
          iprot.skip(ftype)
10368 
      else:
10369 
        iprot.skip(ftype)
10370 
      iprot.readFieldEnd()
10371 
    iprot.readStructEnd()
10372 
 
10373 
  def write(self, oprot):
10374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10376 
      return
10377 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10378 
    if self.success is not None:
10379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10380 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10381 
      for iter115 in self.success:
10382 
        oprot.writeI64(iter115)
5944 mandeep.dh 10383 
      oprot.writeListEnd()
10384 
      oprot.writeFieldEnd()
10385 
    if self.cex is not None:
10386 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10387 
      self.cex.write(oprot)
10388 
      oprot.writeFieldEnd()
10389 
    oprot.writeFieldStop()
10390 
    oprot.writeStructEnd()
10391 
 
10392 
  def validate(self):
10393 
    return
10394 
 
10395 
 
10396 
  def __repr__(self):
10397 
    L = ['%s=%r' % (key, value)
10398 
      for key, value in self.__dict__.iteritems()]
10399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10400 
 
10401 
  def __eq__(self, other):
10402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10403 
 
10404 
  def __ne__(self, other):
10405 
    return not (self == other)
10406 
 
10407 
class getBestDealsCount_args:
10408 
 
10409 
  thrift_spec = (
10410 
  )
10411 
 
10412 
  def read(self, iprot):
10413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10415 
      return
10416 
    iprot.readStructBegin()
10417 
    while True:
10418 
      (fname, ftype, fid) = iprot.readFieldBegin()
10419 
      if ftype == TType.STOP:
10420 
        break
10421 
      else:
10422 
        iprot.skip(ftype)
10423 
      iprot.readFieldEnd()
10424 
    iprot.readStructEnd()
10425 
 
10426 
  def write(self, oprot):
10427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10429 
      return
10430 
    oprot.writeStructBegin('getBestDealsCount_args')
10431 
    oprot.writeFieldStop()
10432 
    oprot.writeStructEnd()
10433 
 
10434 
  def validate(self):
10435 
    return
10436 
 
10437 
 
10438 
  def __repr__(self):
10439 
    L = ['%s=%r' % (key, value)
10440 
      for key, value in self.__dict__.iteritems()]
10441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10442 
 
10443 
  def __eq__(self, other):
10444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10445 
 
10446 
  def __ne__(self, other):
10447 
    return not (self == other)
10448 
 
10449 
class getBestDealsCount_result:
10450 
  """
10451 
  Attributes:
10452 
   - success
10453 
   - cex
10454 
  """
10455 
 
10456 
  thrift_spec = (
10457 
    (0, TType.I64, 'success', None, None, ), # 0
10458 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10459 
  )
10460 
 
10461 
  def __init__(self, success=None, cex=None,):
10462 
    self.success = success
10463 
    self.cex = cex
10464 
 
10465 
  def read(self, iprot):
10466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10468 
      return
10469 
    iprot.readStructBegin()
10470 
    while True:
10471 
      (fname, ftype, fid) = iprot.readFieldBegin()
10472 
      if ftype == TType.STOP:
10473 
        break
10474 
      if fid == 0:
10475 
        if ftype == TType.I64:
10476 
          self.success = iprot.readI64();
10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 1:
10480 
        if ftype == TType.STRUCT:
10481 
          self.cex = CatalogServiceException()
10482 
          self.cex.read(iprot)
10483 
        else:
10484 
          iprot.skip(ftype)
10485 
      else:
10486 
        iprot.skip(ftype)
10487 
      iprot.readFieldEnd()
10488 
    iprot.readStructEnd()
10489 
 
10490 
  def write(self, oprot):
10491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10493 
      return
10494 
    oprot.writeStructBegin('getBestDealsCount_result')
10495 
    if self.success is not None:
10496 
      oprot.writeFieldBegin('success', TType.I64, 0)
10497 
      oprot.writeI64(self.success)
10498 
      oprot.writeFieldEnd()
10499 
    if self.cex is not None:
10500 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10501 
      self.cex.write(oprot)
10502 
      oprot.writeFieldEnd()
10503 
    oprot.writeFieldStop()
10504 
    oprot.writeStructEnd()
10505 
 
10506 
  def validate(self):
10507 
    return
10508 
 
10509 
 
10510 
  def __repr__(self):
10511 
    L = ['%s=%r' % (key, value)
10512 
      for key, value in self.__dict__.iteritems()]
10513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10514 
 
10515 
  def __eq__(self, other):
10516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10517 
 
10518 
  def __ne__(self, other):
10519 
    return not (self == other)
10520 
 
10521 
class getComingSoon_args:
10522 
 
10523 
  thrift_spec = (
10524 
  )
10525 
 
10526 
  def read(self, iprot):
10527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10529 
      return
10530 
    iprot.readStructBegin()
10531 
    while True:
10532 
      (fname, ftype, fid) = iprot.readFieldBegin()
10533 
      if ftype == TType.STOP:
10534 
        break
10535 
      else:
10536 
        iprot.skip(ftype)
10537 
      iprot.readFieldEnd()
10538 
    iprot.readStructEnd()
10539 
 
10540 
  def write(self, oprot):
10541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10543 
      return
10544 
    oprot.writeStructBegin('getComingSoon_args')
10545 
    oprot.writeFieldStop()
10546 
    oprot.writeStructEnd()
10547 
 
10548 
  def validate(self):
10549 
    return
10550 
 
10551 
 
10552 
  def __repr__(self):
10553 
    L = ['%s=%r' % (key, value)
10554 
      for key, value in self.__dict__.iteritems()]
10555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10556 
 
10557 
  def __eq__(self, other):
10558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10559 
 
10560 
  def __ne__(self, other):
10561 
    return not (self == other)
10562 
 
10563 
class getComingSoon_result:
10564 
  """
10565 
  Attributes:
10566 
   - success
10567 
   - isex
10568 
  """
10569 
 
10570 
  thrift_spec = (
10571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10572 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10573 
  )
10574 
 
10575 
  def __init__(self, success=None, isex=None,):
10576 
    self.success = success
10577 
    self.isex = isex
10578 
 
10579 
  def read(self, iprot):
10580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10582 
      return
10583 
    iprot.readStructBegin()
10584 
    while True:
10585 
      (fname, ftype, fid) = iprot.readFieldBegin()
10586 
      if ftype == TType.STOP:
10587 
        break
10588 
      if fid == 0:
10589 
        if ftype == TType.LIST:
10590 
          self.success = []
8590 kshitij.so 10591 
          (_etype119, _size116) = iprot.readListBegin()
10592 
          for _i120 in xrange(_size116):
10593 
            _elem121 = Item()
10594 
            _elem121.read(iprot)
10595 
            self.success.append(_elem121)
5944 mandeep.dh 10596 
          iprot.readListEnd()
10597 
        else:
10598 
          iprot.skip(ftype)
10599 
      elif fid == 1:
10600 
        if ftype == TType.STRUCT:
10601 
          self.isex = CatalogServiceException()
10602 
          self.isex.read(iprot)
10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      else:
10606 
        iprot.skip(ftype)
10607 
      iprot.readFieldEnd()
10608 
    iprot.readStructEnd()
10609 
 
10610 
  def write(self, oprot):
10611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10613 
      return
10614 
    oprot.writeStructBegin('getComingSoon_result')
10615 
    if self.success is not None:
10616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10618 
      for iter122 in self.success:
10619 
        iter122.write(oprot)
5944 mandeep.dh 10620 
      oprot.writeListEnd()
10621 
      oprot.writeFieldEnd()
10622 
    if self.isex is not None:
10623 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10624 
      self.isex.write(oprot)
10625 
      oprot.writeFieldEnd()
10626 
    oprot.writeFieldStop()
10627 
    oprot.writeStructEnd()
10628 
 
10629 
  def validate(self):
10630 
    return
10631 
 
10632 
 
10633 
  def __repr__(self):
10634 
    L = ['%s=%r' % (key, value)
10635 
      for key, value in self.__dict__.iteritems()]
10636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10637 
 
10638 
  def __eq__(self, other):
10639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10640 
 
10641 
  def __ne__(self, other):
10642 
    return not (self == other)
10643 
 
10644 
class getComingSoonCatalogIds_args:
10645 
  """
10646 
  Attributes:
10647 
   - beginIndex
10648 
   - totalItems
10649 
   - brand
10650 
   - category
10651 
  """
10652 
 
10653 
  thrift_spec = (
10654 
    None, # 0
10655 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10656 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10657 
    (3, TType.STRING, 'brand', None, None, ), # 3
10658 
    (4, TType.I64, 'category', None, None, ), # 4
10659 
  )
10660 
 
10661 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10662 
    self.beginIndex = beginIndex
10663 
    self.totalItems = totalItems
10664 
    self.brand = brand
10665 
    self.category = category
10666 
 
10667 
  def read(self, iprot):
10668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10670 
      return
10671 
    iprot.readStructBegin()
10672 
    while True:
10673 
      (fname, ftype, fid) = iprot.readFieldBegin()
10674 
      if ftype == TType.STOP:
10675 
        break
10676 
      if fid == 1:
10677 
        if ftype == TType.I64:
10678 
          self.beginIndex = iprot.readI64();
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      elif fid == 2:
10682 
        if ftype == TType.I64:
10683 
          self.totalItems = iprot.readI64();
10684 
        else:
10685 
          iprot.skip(ftype)
10686 
      elif fid == 3:
10687 
        if ftype == TType.STRING:
10688 
          self.brand = iprot.readString();
10689 
        else:
10690 
          iprot.skip(ftype)
10691 
      elif fid == 4:
10692 
        if ftype == TType.I64:
10693 
          self.category = iprot.readI64();
10694 
        else:
10695 
          iprot.skip(ftype)
10696 
      else:
10697 
        iprot.skip(ftype)
10698 
      iprot.readFieldEnd()
10699 
    iprot.readStructEnd()
10700 
 
10701 
  def write(self, oprot):
10702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10704 
      return
10705 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10706 
    if self.beginIndex is not None:
10707 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10708 
      oprot.writeI64(self.beginIndex)
10709 
      oprot.writeFieldEnd()
10710 
    if self.totalItems is not None:
10711 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10712 
      oprot.writeI64(self.totalItems)
10713 
      oprot.writeFieldEnd()
10714 
    if self.brand is not None:
10715 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10716 
      oprot.writeString(self.brand)
10717 
      oprot.writeFieldEnd()
10718 
    if self.category is not None:
10719 
      oprot.writeFieldBegin('category', TType.I64, 4)
10720 
      oprot.writeI64(self.category)
10721 
      oprot.writeFieldEnd()
10722 
    oprot.writeFieldStop()
10723 
    oprot.writeStructEnd()
10724 
 
10725 
  def validate(self):
10726 
    return
10727 
 
10728 
 
10729 
  def __repr__(self):
10730 
    L = ['%s=%r' % (key, value)
10731 
      for key, value in self.__dict__.iteritems()]
10732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10733 
 
10734 
  def __eq__(self, other):
10735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10736 
 
10737 
  def __ne__(self, other):
10738 
    return not (self == other)
10739 
 
10740 
class getComingSoonCatalogIds_result:
10741 
  """
10742 
  Attributes:
10743 
   - success
10744 
   - cex
10745 
  """
10746 
 
10747 
  thrift_spec = (
10748 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10749 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10750 
  )
10751 
 
10752 
  def __init__(self, success=None, cex=None,):
10753 
    self.success = success
10754 
    self.cex = cex
10755 
 
10756 
  def read(self, iprot):
10757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10759 
      return
10760 
    iprot.readStructBegin()
10761 
    while True:
10762 
      (fname, ftype, fid) = iprot.readFieldBegin()
10763 
      if ftype == TType.STOP:
10764 
        break
10765 
      if fid == 0:
10766 
        if ftype == TType.LIST:
10767 
          self.success = []
8590 kshitij.so 10768 
          (_etype126, _size123) = iprot.readListBegin()
10769 
          for _i127 in xrange(_size123):
10770 
            _elem128 = iprot.readI64();
10771 
            self.success.append(_elem128)
5944 mandeep.dh 10772 
          iprot.readListEnd()
10773 
        else:
10774 
          iprot.skip(ftype)
10775 
      elif fid == 1:
10776 
        if ftype == TType.STRUCT:
10777 
          self.cex = CatalogServiceException()
10778 
          self.cex.read(iprot)
10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      else:
10782 
        iprot.skip(ftype)
10783 
      iprot.readFieldEnd()
10784 
    iprot.readStructEnd()
10785 
 
10786 
  def write(self, oprot):
10787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10789 
      return
10790 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10791 
    if self.success is not None:
10792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10793 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10794 
      for iter129 in self.success:
10795 
        oprot.writeI64(iter129)
5944 mandeep.dh 10796 
      oprot.writeListEnd()
10797 
      oprot.writeFieldEnd()
10798 
    if self.cex is not None:
10799 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10800 
      self.cex.write(oprot)
10801 
      oprot.writeFieldEnd()
10802 
    oprot.writeFieldStop()
10803 
    oprot.writeStructEnd()
10804 
 
10805 
  def validate(self):
10806 
    return
10807 
 
10808 
 
10809 
  def __repr__(self):
10810 
    L = ['%s=%r' % (key, value)
10811 
      for key, value in self.__dict__.iteritems()]
10812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10813 
 
10814 
  def __eq__(self, other):
10815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10816 
 
10817 
  def __ne__(self, other):
10818 
    return not (self == other)
10819 
 
10820 
class getComingSoonCount_args:
10821 
 
10822 
  thrift_spec = (
10823 
  )
10824 
 
10825 
  def read(self, iprot):
10826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10828 
      return
10829 
    iprot.readStructBegin()
10830 
    while True:
10831 
      (fname, ftype, fid) = iprot.readFieldBegin()
10832 
      if ftype == TType.STOP:
10833 
        break
10834 
      else:
10835 
        iprot.skip(ftype)
10836 
      iprot.readFieldEnd()
10837 
    iprot.readStructEnd()
10838 
 
10839 
  def write(self, oprot):
10840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10842 
      return
10843 
    oprot.writeStructBegin('getComingSoonCount_args')
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
10862 
class getComingSoonCount_result:
10863 
  """
10864 
  Attributes:
10865 
   - success
10866 
   - cex
10867 
  """
10868 
 
10869 
  thrift_spec = (
10870 
    (0, TType.I64, 'success', None, None, ), # 0
10871 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10872 
  )
10873 
 
10874 
  def __init__(self, success=None, cex=None,):
10875 
    self.success = success
10876 
    self.cex = cex
10877 
 
10878 
  def read(self, iprot):
10879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10881 
      return
10882 
    iprot.readStructBegin()
10883 
    while True:
10884 
      (fname, ftype, fid) = iprot.readFieldBegin()
10885 
      if ftype == TType.STOP:
10886 
        break
10887 
      if fid == 0:
10888 
        if ftype == TType.I64:
10889 
          self.success = iprot.readI64();
10890 
        else:
10891 
          iprot.skip(ftype)
10892 
      elif fid == 1:
10893 
        if ftype == TType.STRUCT:
10894 
          self.cex = CatalogServiceException()
10895 
          self.cex.read(iprot)
10896 
        else:
10897 
          iprot.skip(ftype)
10898 
      else:
10899 
        iprot.skip(ftype)
10900 
      iprot.readFieldEnd()
10901 
    iprot.readStructEnd()
10902 
 
10903 
  def write(self, oprot):
10904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10906 
      return
10907 
    oprot.writeStructBegin('getComingSoonCount_result')
10908 
    if self.success is not None:
10909 
      oprot.writeFieldBegin('success', TType.I64, 0)
10910 
      oprot.writeI64(self.success)
10911 
      oprot.writeFieldEnd()
10912 
    if self.cex is not None:
10913 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10914 
      self.cex.write(oprot)
10915 
      oprot.writeFieldEnd()
10916 
    oprot.writeFieldStop()
10917 
    oprot.writeStructEnd()
10918 
 
10919 
  def validate(self):
10920 
    return
10921 
 
10922 
 
10923 
  def __repr__(self):
10924 
    L = ['%s=%r' % (key, value)
10925 
      for key, value in self.__dict__.iteritems()]
10926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10927 
 
10928 
  def __eq__(self, other):
10929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10930 
 
10931 
  def __ne__(self, other):
10932 
    return not (self == other)
10933 
 
10934 
class getLatestArrivals_args:
10935 
 
10936 
  thrift_spec = (
10937 
  )
10938 
 
10939 
  def read(self, iprot):
10940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10942 
      return
10943 
    iprot.readStructBegin()
10944 
    while True:
10945 
      (fname, ftype, fid) = iprot.readFieldBegin()
10946 
      if ftype == TType.STOP:
10947 
        break
10948 
      else:
10949 
        iprot.skip(ftype)
10950 
      iprot.readFieldEnd()
10951 
    iprot.readStructEnd()
10952 
 
10953 
  def write(self, oprot):
10954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10956 
      return
10957 
    oprot.writeStructBegin('getLatestArrivals_args')
10958 
    oprot.writeFieldStop()
10959 
    oprot.writeStructEnd()
10960 
 
10961 
  def validate(self):
10962 
    return
10963 
 
10964 
 
10965 
  def __repr__(self):
10966 
    L = ['%s=%r' % (key, value)
10967 
      for key, value in self.__dict__.iteritems()]
10968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10969 
 
10970 
  def __eq__(self, other):
10971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10972 
 
10973 
  def __ne__(self, other):
10974 
    return not (self == other)
10975 
 
10976 
class getLatestArrivals_result:
10977 
  """
10978 
  Attributes:
10979 
   - success
10980 
   - isex
10981 
  """
10982 
 
10983 
  thrift_spec = (
10984 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10985 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10986 
  )
10987 
 
10988 
  def __init__(self, success=None, isex=None,):
10989 
    self.success = success
10990 
    self.isex = isex
10991 
 
10992 
  def read(self, iprot):
10993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10995 
      return
10996 
    iprot.readStructBegin()
10997 
    while True:
10998 
      (fname, ftype, fid) = iprot.readFieldBegin()
10999 
      if ftype == TType.STOP:
11000 
        break
11001 
      if fid == 0:
11002 
        if ftype == TType.LIST:
11003 
          self.success = []
8590 kshitij.so 11004 
          (_etype133, _size130) = iprot.readListBegin()
11005 
          for _i134 in xrange(_size130):
11006 
            _elem135 = Item()
11007 
            _elem135.read(iprot)
11008 
            self.success.append(_elem135)
5944 mandeep.dh 11009 
          iprot.readListEnd()
11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      elif fid == 1:
11013 
        if ftype == TType.STRUCT:
11014 
          self.isex = CatalogServiceException()
11015 
          self.isex.read(iprot)
11016 
        else:
11017 
          iprot.skip(ftype)
11018 
      else:
11019 
        iprot.skip(ftype)
11020 
      iprot.readFieldEnd()
11021 
    iprot.readStructEnd()
11022 
 
11023 
  def write(self, oprot):
11024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11026 
      return
11027 
    oprot.writeStructBegin('getLatestArrivals_result')
11028 
    if self.success is not None:
11029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11031 
      for iter136 in self.success:
11032 
        iter136.write(oprot)
5944 mandeep.dh 11033 
      oprot.writeListEnd()
11034 
      oprot.writeFieldEnd()
11035 
    if self.isex is not None:
11036 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11037 
      self.isex.write(oprot)
11038 
      oprot.writeFieldEnd()
11039 
    oprot.writeFieldStop()
11040 
    oprot.writeStructEnd()
11041 
 
11042 
  def validate(self):
11043 
    return
11044 
 
11045 
 
11046 
  def __repr__(self):
11047 
    L = ['%s=%r' % (key, value)
11048 
      for key, value in self.__dict__.iteritems()]
11049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11050 
 
11051 
  def __eq__(self, other):
11052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11053 
 
11054 
  def __ne__(self, other):
11055 
    return not (self == other)
11056 
 
11057 
class getLatestArrivalsCatalogIds_args:
11058 
  """
11059 
  Attributes:
11060 
   - beginIndex
11061 
   - totalItems
11062 
   - brand
11063 
   - categories
11064 
  """
11065 
 
11066 
  thrift_spec = (
11067 
    None, # 0
11068 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11069 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11070 
    (3, TType.STRING, 'brand', None, None, ), # 3
11071 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11072 
  )
11073 
 
11074 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11075 
    self.beginIndex = beginIndex
11076 
    self.totalItems = totalItems
11077 
    self.brand = brand
11078 
    self.categories = categories
11079 
 
11080 
  def read(self, iprot):
11081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11083 
      return
11084 
    iprot.readStructBegin()
11085 
    while True:
11086 
      (fname, ftype, fid) = iprot.readFieldBegin()
11087 
      if ftype == TType.STOP:
11088 
        break
11089 
      if fid == 1:
11090 
        if ftype == TType.I64:
11091 
          self.beginIndex = iprot.readI64();
11092 
        else:
11093 
          iprot.skip(ftype)
11094 
      elif fid == 2:
11095 
        if ftype == TType.I64:
11096 
          self.totalItems = iprot.readI64();
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      elif fid == 3:
11100 
        if ftype == TType.STRING:
11101 
          self.brand = iprot.readString();
11102 
        else:
11103 
          iprot.skip(ftype)
11104 
      elif fid == 4:
11105 
        if ftype == TType.LIST:
11106 
          self.categories = []
8590 kshitij.so 11107 
          (_etype140, _size137) = iprot.readListBegin()
11108 
          for _i141 in xrange(_size137):
11109 
            _elem142 = iprot.readI64();
11110 
            self.categories.append(_elem142)
5944 mandeep.dh 11111 
          iprot.readListEnd()
11112 
        else:
11113 
          iprot.skip(ftype)
11114 
      else:
11115 
        iprot.skip(ftype)
11116 
      iprot.readFieldEnd()
11117 
    iprot.readStructEnd()
11118 
 
11119 
  def write(self, oprot):
11120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11122 
      return
11123 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11124 
    if self.beginIndex is not None:
11125 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11126 
      oprot.writeI64(self.beginIndex)
11127 
      oprot.writeFieldEnd()
11128 
    if self.totalItems is not None:
11129 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11130 
      oprot.writeI64(self.totalItems)
11131 
      oprot.writeFieldEnd()
11132 
    if self.brand is not None:
11133 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11134 
      oprot.writeString(self.brand)
11135 
      oprot.writeFieldEnd()
11136 
    if self.categories is not None:
11137 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11138 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11139 
      for iter143 in self.categories:
11140 
        oprot.writeI64(iter143)
5944 mandeep.dh 11141 
      oprot.writeListEnd()
11142 
      oprot.writeFieldEnd()
11143 
    oprot.writeFieldStop()
11144 
    oprot.writeStructEnd()
11145 
 
11146 
  def validate(self):
11147 
    return
11148 
 
11149 
 
11150 
  def __repr__(self):
11151 
    L = ['%s=%r' % (key, value)
11152 
      for key, value in self.__dict__.iteritems()]
11153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11154 
 
11155 
  def __eq__(self, other):
11156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11157 
 
11158 
  def __ne__(self, other):
11159 
    return not (self == other)
11160 
 
11161 
class getLatestArrivalsCatalogIds_result:
11162 
  """
11163 
  Attributes:
11164 
   - success
11165 
   - cex
11166 
  """
11167 
 
11168 
  thrift_spec = (
11169 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11170 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11171 
  )
11172 
 
11173 
  def __init__(self, success=None, cex=None,):
11174 
    self.success = success
11175 
    self.cex = cex
11176 
 
11177 
  def read(self, iprot):
11178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11180 
      return
11181 
    iprot.readStructBegin()
11182 
    while True:
11183 
      (fname, ftype, fid) = iprot.readFieldBegin()
11184 
      if ftype == TType.STOP:
11185 
        break
11186 
      if fid == 0:
11187 
        if ftype == TType.LIST:
11188 
          self.success = []
8590 kshitij.so 11189 
          (_etype147, _size144) = iprot.readListBegin()
11190 
          for _i148 in xrange(_size144):
11191 
            _elem149 = iprot.readI64();
11192 
            self.success.append(_elem149)
5944 mandeep.dh 11193 
          iprot.readListEnd()
11194 
        else:
11195 
          iprot.skip(ftype)
11196 
      elif fid == 1:
11197 
        if ftype == TType.STRUCT:
11198 
          self.cex = CatalogServiceException()
11199 
          self.cex.read(iprot)
11200 
        else:
11201 
          iprot.skip(ftype)
11202 
      else:
11203 
        iprot.skip(ftype)
11204 
      iprot.readFieldEnd()
11205 
    iprot.readStructEnd()
11206 
 
11207 
  def write(self, oprot):
11208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11210 
      return
11211 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11212 
    if self.success is not None:
11213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11214 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11215 
      for iter150 in self.success:
11216 
        oprot.writeI64(iter150)
5944 mandeep.dh 11217 
      oprot.writeListEnd()
11218 
      oprot.writeFieldEnd()
11219 
    if self.cex is not None:
11220 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11221 
      self.cex.write(oprot)
11222 
      oprot.writeFieldEnd()
11223 
    oprot.writeFieldStop()
11224 
    oprot.writeStructEnd()
11225 
 
11226 
  def validate(self):
11227 
    return
11228 
 
11229 
 
11230 
  def __repr__(self):
11231 
    L = ['%s=%r' % (key, value)
11232 
      for key, value in self.__dict__.iteritems()]
11233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11234 
 
11235 
  def __eq__(self, other):
11236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11237 
 
11238 
  def __ne__(self, other):
11239 
    return not (self == other)
11240 
 
11241 
class getLatestArrivalsCount_args:
11242 
 
11243 
  thrift_spec = (
11244 
  )
11245 
 
11246 
  def read(self, iprot):
11247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11249 
      return
11250 
    iprot.readStructBegin()
11251 
    while True:
11252 
      (fname, ftype, fid) = iprot.readFieldBegin()
11253 
      if ftype == TType.STOP:
11254 
        break
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
11264 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11265 
    oprot.writeFieldStop()
11266 
    oprot.writeStructEnd()
11267 
 
11268 
  def validate(self):
11269 
    return
11270 
 
11271 
 
11272 
  def __repr__(self):
11273 
    L = ['%s=%r' % (key, value)
11274 
      for key, value in self.__dict__.iteritems()]
11275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11276 
 
11277 
  def __eq__(self, other):
11278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11279 
 
11280 
  def __ne__(self, other):
11281 
    return not (self == other)
11282 
 
11283 
class getLatestArrivalsCount_result:
11284 
  """
11285 
  Attributes:
11286 
   - success
11287 
   - cex
11288 
  """
11289 
 
11290 
  thrift_spec = (
11291 
    (0, TType.I64, 'success', None, None, ), # 0
11292 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11293 
  )
11294 
 
11295 
  def __init__(self, success=None, cex=None,):
11296 
    self.success = success
11297 
    self.cex = cex
11298 
 
11299 
  def read(self, iprot):
11300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11302 
      return
11303 
    iprot.readStructBegin()
11304 
    while True:
11305 
      (fname, ftype, fid) = iprot.readFieldBegin()
11306 
      if ftype == TType.STOP:
11307 
        break
11308 
      if fid == 0:
11309 
        if ftype == TType.I64:
11310 
          self.success = iprot.readI64();
11311 
        else:
11312 
          iprot.skip(ftype)
11313 
      elif fid == 1:
11314 
        if ftype == TType.STRUCT:
11315 
          self.cex = CatalogServiceException()
11316 
          self.cex.read(iprot)
11317 
        else:
11318 
          iprot.skip(ftype)
11319 
      else:
11320 
        iprot.skip(ftype)
11321 
      iprot.readFieldEnd()
11322 
    iprot.readStructEnd()
11323 
 
11324 
  def write(self, oprot):
11325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11327 
      return
11328 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11329 
    if self.success is not None:
11330 
      oprot.writeFieldBegin('success', TType.I64, 0)
11331 
      oprot.writeI64(self.success)
11332 
      oprot.writeFieldEnd()
11333 
    if self.cex is not None:
11334 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11335 
      self.cex.write(oprot)
11336 
      oprot.writeFieldEnd()
11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
11340 
  def validate(self):
11341 
    return
11342 
 
11343 
 
11344 
  def __repr__(self):
11345 
    L = ['%s=%r' % (key, value)
11346 
      for key, value in self.__dict__.iteritems()]
11347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11348 
 
11349 
  def __eq__(self, other):
11350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11351 
 
11352 
  def __ne__(self, other):
11353 
    return not (self == other)
11354 
 
11355 
class generateNewEntityID_args:
11356 
 
11357 
  thrift_spec = (
11358 
  )
11359 
 
11360 
  def read(self, iprot):
11361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11363 
      return
11364 
    iprot.readStructBegin()
11365 
    while True:
11366 
      (fname, ftype, fid) = iprot.readFieldBegin()
11367 
      if ftype == TType.STOP:
11368 
        break
11369 
      else:
11370 
        iprot.skip(ftype)
11371 
      iprot.readFieldEnd()
11372 
    iprot.readStructEnd()
11373 
 
11374 
  def write(self, oprot):
11375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11377 
      return
11378 
    oprot.writeStructBegin('generateNewEntityID_args')
11379 
    oprot.writeFieldStop()
11380 
    oprot.writeStructEnd()
11381 
 
11382 
  def validate(self):
11383 
    return
11384 
 
11385 
 
11386 
  def __repr__(self):
11387 
    L = ['%s=%r' % (key, value)
11388 
      for key, value in self.__dict__.iteritems()]
11389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11390 
 
11391 
  def __eq__(self, other):
11392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11393 
 
11394 
  def __ne__(self, other):
11395 
    return not (self == other)
11396 
 
11397 
class generateNewEntityID_result:
11398 
  """
11399 
  Attributes:
11400 
   - success
11401 
  """
11402 
 
11403 
  thrift_spec = (
11404 
    (0, TType.I64, 'success', None, None, ), # 0
11405 
  )
11406 
 
11407 
  def __init__(self, success=None,):
11408 
    self.success = success
11409 
 
11410 
  def read(self, iprot):
11411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11413 
      return
11414 
    iprot.readStructBegin()
11415 
    while True:
11416 
      (fname, ftype, fid) = iprot.readFieldBegin()
11417 
      if ftype == TType.STOP:
11418 
        break
11419 
      if fid == 0:
11420 
        if ftype == TType.I64:
11421 
          self.success = iprot.readI64();
11422 
        else:
11423 
          iprot.skip(ftype)
11424 
      else:
11425 
        iprot.skip(ftype)
11426 
      iprot.readFieldEnd()
11427 
    iprot.readStructEnd()
11428 
 
11429 
  def write(self, oprot):
11430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11432 
      return
11433 
    oprot.writeStructBegin('generateNewEntityID_result')
11434 
    if self.success is not None:
11435 
      oprot.writeFieldBegin('success', TType.I64, 0)
11436 
      oprot.writeI64(self.success)
11437 
      oprot.writeFieldEnd()
11438 
    oprot.writeFieldStop()
11439 
    oprot.writeStructEnd()
11440 
 
11441 
  def validate(self):
11442 
    return
11443 
 
11444 
 
11445 
  def __repr__(self):
11446 
    L = ['%s=%r' % (key, value)
11447 
      for key, value in self.__dict__.iteritems()]
11448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11449 
 
11450 
  def __eq__(self, other):
11451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11452 
 
11453 
  def __ne__(self, other):
11454 
    return not (self == other)
11455 
 
11456 
class addCategory_args:
11457 
  """
11458 
  Attributes:
11459 
   - category
11460 
  """
11461 
 
11462 
  thrift_spec = (
11463 
    None, # 0
11464 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11465 
  )
11466 
 
11467 
  def __init__(self, category=None,):
11468 
    self.category = category
11469 
 
11470 
  def read(self, iprot):
11471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11473 
      return
11474 
    iprot.readStructBegin()
11475 
    while True:
11476 
      (fname, ftype, fid) = iprot.readFieldBegin()
11477 
      if ftype == TType.STOP:
11478 
        break
11479 
      if fid == 1:
11480 
        if ftype == TType.STRUCT:
11481 
          self.category = Category()
11482 
          self.category.read(iprot)
11483 
        else:
11484 
          iprot.skip(ftype)
11485 
      else:
11486 
        iprot.skip(ftype)
11487 
      iprot.readFieldEnd()
11488 
    iprot.readStructEnd()
11489 
 
11490 
  def write(self, oprot):
11491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11493 
      return
11494 
    oprot.writeStructBegin('addCategory_args')
11495 
    if self.category is not None:
11496 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11497 
      self.category.write(oprot)
11498 
      oprot.writeFieldEnd()
11499 
    oprot.writeFieldStop()
11500 
    oprot.writeStructEnd()
11501 
 
11502 
  def validate(self):
11503 
    return
11504 
 
11505 
 
11506 
  def __repr__(self):
11507 
    L = ['%s=%r' % (key, value)
11508 
      for key, value in self.__dict__.iteritems()]
11509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11510 
 
11511 
  def __eq__(self, other):
11512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11513 
 
11514 
  def __ne__(self, other):
11515 
    return not (self == other)
11516 
 
11517 
class addCategory_result:
11518 
  """
11519 
  Attributes:
11520 
   - success
11521 
  """
11522 
 
11523 
  thrift_spec = (
11524 
    (0, TType.BOOL, 'success', None, None, ), # 0
11525 
  )
11526 
 
11527 
  def __init__(self, success=None,):
11528 
    self.success = success
11529 
 
11530 
  def read(self, iprot):
11531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11533 
      return
11534 
    iprot.readStructBegin()
11535 
    while True:
11536 
      (fname, ftype, fid) = iprot.readFieldBegin()
11537 
      if ftype == TType.STOP:
11538 
        break
11539 
      if fid == 0:
11540 
        if ftype == TType.BOOL:
11541 
          self.success = iprot.readBool();
11542 
        else:
11543 
          iprot.skip(ftype)
11544 
      else:
11545 
        iprot.skip(ftype)
11546 
      iprot.readFieldEnd()
11547 
    iprot.readStructEnd()
11548 
 
11549 
  def write(self, oprot):
11550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11552 
      return
11553 
    oprot.writeStructBegin('addCategory_result')
11554 
    if self.success is not None:
11555 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11556 
      oprot.writeBool(self.success)
11557 
      oprot.writeFieldEnd()
11558 
    oprot.writeFieldStop()
11559 
    oprot.writeStructEnd()
11560 
 
11561 
  def validate(self):
11562 
    return
11563 
 
11564 
 
11565 
  def __repr__(self):
11566 
    L = ['%s=%r' % (key, value)
11567 
      for key, value in self.__dict__.iteritems()]
11568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11569 
 
11570 
  def __eq__(self, other):
11571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11572 
 
11573 
  def __ne__(self, other):
11574 
    return not (self == other)
11575 
 
11576 
class getCategory_args:
11577 
  """
11578 
  Attributes:
11579 
   - id
11580 
  """
11581 
 
11582 
  thrift_spec = (
11583 
    None, # 0
11584 
    (1, TType.I64, 'id', None, None, ), # 1
11585 
  )
11586 
 
11587 
  def __init__(self, id=None,):
11588 
    self.id = id
11589 
 
11590 
  def read(self, iprot):
11591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11593 
      return
11594 
    iprot.readStructBegin()
11595 
    while True:
11596 
      (fname, ftype, fid) = iprot.readFieldBegin()
11597 
      if ftype == TType.STOP:
11598 
        break
11599 
      if fid == 1:
11600 
        if ftype == TType.I64:
11601 
          self.id = iprot.readI64();
11602 
        else:
11603 
          iprot.skip(ftype)
11604 
      else:
11605 
        iprot.skip(ftype)
11606 
      iprot.readFieldEnd()
11607 
    iprot.readStructEnd()
11608 
 
11609 
  def write(self, oprot):
11610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11612 
      return
11613 
    oprot.writeStructBegin('getCategory_args')
11614 
    if self.id is not None:
11615 
      oprot.writeFieldBegin('id', TType.I64, 1)
11616 
      oprot.writeI64(self.id)
11617 
      oprot.writeFieldEnd()
11618 
    oprot.writeFieldStop()
11619 
    oprot.writeStructEnd()
11620 
 
11621 
  def validate(self):
11622 
    return
11623 
 
11624 
 
11625 
  def __repr__(self):
11626 
    L = ['%s=%r' % (key, value)
11627 
      for key, value in self.__dict__.iteritems()]
11628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11629 
 
11630 
  def __eq__(self, other):
11631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11632 
 
11633 
  def __ne__(self, other):
11634 
    return not (self == other)
11635 
 
11636 
class getCategory_result:
11637 
  """
11638 
  Attributes:
11639 
   - success
11640 
  """
11641 
 
11642 
  thrift_spec = (
11643 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11644 
  )
11645 
 
11646 
  def __init__(self, success=None,):
11647 
    self.success = success
11648 
 
11649 
  def read(self, iprot):
11650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11652 
      return
11653 
    iprot.readStructBegin()
11654 
    while True:
11655 
      (fname, ftype, fid) = iprot.readFieldBegin()
11656 
      if ftype == TType.STOP:
11657 
        break
11658 
      if fid == 0:
11659 
        if ftype == TType.STRUCT:
11660 
          self.success = Category()
11661 
          self.success.read(iprot)
11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      else:
11665 
        iprot.skip(ftype)
11666 
      iprot.readFieldEnd()
11667 
    iprot.readStructEnd()
11668 
 
11669 
  def write(self, oprot):
11670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11672 
      return
11673 
    oprot.writeStructBegin('getCategory_result')
11674 
    if self.success is not None:
11675 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11676 
      self.success.write(oprot)
11677 
      oprot.writeFieldEnd()
11678 
    oprot.writeFieldStop()
11679 
    oprot.writeStructEnd()
11680 
 
11681 
  def validate(self):
11682 
    return
11683 
 
11684 
 
11685 
  def __repr__(self):
11686 
    L = ['%s=%r' % (key, value)
11687 
      for key, value in self.__dict__.iteritems()]
11688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11689 
 
11690 
  def __eq__(self, other):
11691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11692 
 
11693 
  def __ne__(self, other):
11694 
    return not (self == other)
11695 
 
11696 
class getAllCategories_args:
11697 
 
11698 
  thrift_spec = (
11699 
  )
11700 
 
11701 
  def read(self, iprot):
11702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11704 
      return
11705 
    iprot.readStructBegin()
11706 
    while True:
11707 
      (fname, ftype, fid) = iprot.readFieldBegin()
11708 
      if ftype == TType.STOP:
11709 
        break
11710 
      else:
11711 
        iprot.skip(ftype)
11712 
      iprot.readFieldEnd()
11713 
    iprot.readStructEnd()
11714 
 
11715 
  def write(self, oprot):
11716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11718 
      return
11719 
    oprot.writeStructBegin('getAllCategories_args')
11720 
    oprot.writeFieldStop()
11721 
    oprot.writeStructEnd()
11722 
 
11723 
  def validate(self):
11724 
    return
11725 
 
11726 
 
11727 
  def __repr__(self):
11728 
    L = ['%s=%r' % (key, value)
11729 
      for key, value in self.__dict__.iteritems()]
11730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11731 
 
11732 
  def __eq__(self, other):
11733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11734 
 
11735 
  def __ne__(self, other):
11736 
    return not (self == other)
11737 
 
11738 
class getAllCategories_result:
11739 
  """
11740 
  Attributes:
11741 
   - success
11742 
  """
11743 
 
11744 
  thrift_spec = (
11745 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11746 
  )
11747 
 
11748 
  def __init__(self, success=None,):
11749 
    self.success = success
11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 0:
11761 
        if ftype == TType.LIST:
11762 
          self.success = []
8590 kshitij.so 11763 
          (_etype154, _size151) = iprot.readListBegin()
11764 
          for _i155 in xrange(_size151):
11765 
            _elem156 = Category()
11766 
            _elem156.read(iprot)
11767 
            self.success.append(_elem156)
5944 mandeep.dh 11768 
          iprot.readListEnd()
11769 
        else:
11770 
          iprot.skip(ftype)
11771 
      else:
11772 
        iprot.skip(ftype)
11773 
      iprot.readFieldEnd()
11774 
    iprot.readStructEnd()
11775 
 
11776 
  def write(self, oprot):
11777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11779 
      return
11780 
    oprot.writeStructBegin('getAllCategories_result')
11781 
    if self.success is not None:
11782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11784 
      for iter157 in self.success:
11785 
        iter157.write(oprot)
5944 mandeep.dh 11786 
      oprot.writeListEnd()
11787 
      oprot.writeFieldEnd()
11788 
    oprot.writeFieldStop()
11789 
    oprot.writeStructEnd()
11790 
 
11791 
  def validate(self):
11792 
    return
11793 
 
11794 
 
11795 
  def __repr__(self):
11796 
    L = ['%s=%r' % (key, value)
11797 
      for key, value in self.__dict__.iteritems()]
11798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11799 
 
11800 
  def __eq__(self, other):
11801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11802 
 
11803 
  def __ne__(self, other):
11804 
    return not (self == other)
11805 
 
11806 
class getAllSimilarItems_args:
11807 
  """
11808 
  Attributes:
11809 
   - itemId
11810 
  """
11811 
 
11812 
  thrift_spec = (
11813 
    None, # 0
11814 
    (1, TType.I64, 'itemId', None, None, ), # 1
11815 
  )
11816 
 
11817 
  def __init__(self, itemId=None,):
11818 
    self.itemId = itemId
11819 
 
11820 
  def read(self, iprot):
11821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11823 
      return
11824 
    iprot.readStructBegin()
11825 
    while True:
11826 
      (fname, ftype, fid) = iprot.readFieldBegin()
11827 
      if ftype == TType.STOP:
11828 
        break
11829 
      if fid == 1:
11830 
        if ftype == TType.I64:
11831 
          self.itemId = iprot.readI64();
11832 
        else:
11833 
          iprot.skip(ftype)
11834 
      else:
11835 
        iprot.skip(ftype)
11836 
      iprot.readFieldEnd()
11837 
    iprot.readStructEnd()
11838 
 
11839 
  def write(self, oprot):
11840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11842 
      return
11843 
    oprot.writeStructBegin('getAllSimilarItems_args')
11844 
    if self.itemId is not None:
11845 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11846 
      oprot.writeI64(self.itemId)
11847 
      oprot.writeFieldEnd()
11848 
    oprot.writeFieldStop()
11849 
    oprot.writeStructEnd()
11850 
 
11851 
  def validate(self):
11852 
    return
11853 
 
11854 
 
11855 
  def __repr__(self):
11856 
    L = ['%s=%r' % (key, value)
11857 
      for key, value in self.__dict__.iteritems()]
11858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11859 
 
11860 
  def __eq__(self, other):
11861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11862 
 
11863 
  def __ne__(self, other):
11864 
    return not (self == other)
11865 
 
11866 
class getAllSimilarItems_result:
11867 
  """
11868 
  Attributes:
11869 
   - success
11870 
  """
11871 
 
11872 
  thrift_spec = (
11873 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11874 
  )
11875 
 
11876 
  def __init__(self, success=None,):
11877 
    self.success = success
11878 
 
11879 
  def read(self, iprot):
11880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11882 
      return
11883 
    iprot.readStructBegin()
11884 
    while True:
11885 
      (fname, ftype, fid) = iprot.readFieldBegin()
11886 
      if ftype == TType.STOP:
11887 
        break
11888 
      if fid == 0:
11889 
        if ftype == TType.LIST:
11890 
          self.success = []
8590 kshitij.so 11891 
          (_etype161, _size158) = iprot.readListBegin()
11892 
          for _i162 in xrange(_size158):
11893 
            _elem163 = Item()
11894 
            _elem163.read(iprot)
11895 
            self.success.append(_elem163)
5944 mandeep.dh 11896 
          iprot.readListEnd()
11897 
        else:
11898 
          iprot.skip(ftype)
11899 
      else:
11900 
        iprot.skip(ftype)
11901 
      iprot.readFieldEnd()
11902 
    iprot.readStructEnd()
11903 
 
11904 
  def write(self, oprot):
11905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11907 
      return
11908 
    oprot.writeStructBegin('getAllSimilarItems_result')
11909 
    if self.success is not None:
11910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11912 
      for iter164 in self.success:
11913 
        iter164.write(oprot)
5944 mandeep.dh 11914 
      oprot.writeListEnd()
11915 
      oprot.writeFieldEnd()
11916 
    oprot.writeFieldStop()
11917 
    oprot.writeStructEnd()
11918 
 
11919 
  def validate(self):
11920 
    return
11921 
 
11922 
 
11923 
  def __repr__(self):
11924 
    L = ['%s=%r' % (key, value)
11925 
      for key, value in self.__dict__.iteritems()]
11926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11927 
 
11928 
  def __eq__(self, other):
11929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11930 
 
11931 
  def __ne__(self, other):
11932 
    return not (self == other)
11933 
 
11934 
class addSimilarItem_args:
11935 
  """
11936 
  Attributes:
11937 
   - itemId
11938 
   - catalogItemId
11939 
  """
11940 
 
11941 
  thrift_spec = (
11942 
    None, # 0
11943 
    (1, TType.I64, 'itemId', None, None, ), # 1
11944 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11945 
  )
11946 
 
11947 
  def __init__(self, itemId=None, catalogItemId=None,):
11948 
    self.itemId = itemId
11949 
    self.catalogItemId = catalogItemId
11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      if fid == 1:
11961 
        if ftype == TType.I64:
11962 
          self.itemId = iprot.readI64();
11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      elif fid == 2:
11966 
        if ftype == TType.I64:
11967 
          self.catalogItemId = iprot.readI64();
11968 
        else:
11969 
          iprot.skip(ftype)
11970 
      else:
11971 
        iprot.skip(ftype)
11972 
      iprot.readFieldEnd()
11973 
    iprot.readStructEnd()
11974 
 
11975 
  def write(self, oprot):
11976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11978 
      return
11979 
    oprot.writeStructBegin('addSimilarItem_args')
11980 
    if self.itemId is not None:
11981 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11982 
      oprot.writeI64(self.itemId)
11983 
      oprot.writeFieldEnd()
11984 
    if self.catalogItemId is not None:
11985 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11986 
      oprot.writeI64(self.catalogItemId)
11987 
      oprot.writeFieldEnd()
11988 
    oprot.writeFieldStop()
11989 
    oprot.writeStructEnd()
11990 
 
11991 
  def validate(self):
11992 
    return
11993 
 
11994 
 
11995 
  def __repr__(self):
11996 
    L = ['%s=%r' % (key, value)
11997 
      for key, value in self.__dict__.iteritems()]
11998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11999 
 
12000 
  def __eq__(self, other):
12001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12002 
 
12003 
  def __ne__(self, other):
12004 
    return not (self == other)
12005 
 
12006 
class addSimilarItem_result:
12007 
  """
12008 
  Attributes:
12009 
   - success
12010 
   - cex
12011 
  """
12012 
 
12013 
  thrift_spec = (
12014 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12015 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12016 
  )
12017 
 
12018 
  def __init__(self, success=None, cex=None,):
12019 
    self.success = success
12020 
    self.cex = cex
12021 
 
12022 
  def read(self, iprot):
12023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12025 
      return
12026 
    iprot.readStructBegin()
12027 
    while True:
12028 
      (fname, ftype, fid) = iprot.readFieldBegin()
12029 
      if ftype == TType.STOP:
12030 
        break
12031 
      if fid == 0:
12032 
        if ftype == TType.STRUCT:
12033 
          self.success = Item()
12034 
          self.success.read(iprot)
12035 
        else:
12036 
          iprot.skip(ftype)
12037 
      elif fid == 1:
12038 
        if ftype == TType.STRUCT:
12039 
          self.cex = CatalogServiceException()
12040 
          self.cex.read(iprot)
12041 
        else:
12042 
          iprot.skip(ftype)
12043 
      else:
12044 
        iprot.skip(ftype)
12045 
      iprot.readFieldEnd()
12046 
    iprot.readStructEnd()
12047 
 
12048 
  def write(self, oprot):
12049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12051 
      return
12052 
    oprot.writeStructBegin('addSimilarItem_result')
12053 
    if self.success is not None:
12054 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12055 
      self.success.write(oprot)
12056 
      oprot.writeFieldEnd()
12057 
    if self.cex is not None:
12058 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12059 
      self.cex.write(oprot)
12060 
      oprot.writeFieldEnd()
12061 
    oprot.writeFieldStop()
12062 
    oprot.writeStructEnd()
12063 
 
12064 
  def validate(self):
12065 
    return
12066 
 
12067 
 
12068 
  def __repr__(self):
12069 
    L = ['%s=%r' % (key, value)
12070 
      for key, value in self.__dict__.iteritems()]
12071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12072 
 
12073 
  def __eq__(self, other):
12074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12075 
 
12076 
  def __ne__(self, other):
12077 
    return not (self == other)
12078 
 
6512 kshitij.so 12079 
class addTag_args:
12080 
  """
12081 
  Attributes:
12082 
   - displayName
12083 
   - itemId
12084 
  """
12085 
 
12086 
  thrift_spec = (
12087 
    None, # 0
12088 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12089 
    (2, TType.I64, 'itemId', None, None, ), # 2
12090 
  )
12091 
 
12092 
  def __init__(self, displayName=None, itemId=None,):
12093 
    self.displayName = displayName
12094 
    self.itemId = itemId
12095 
 
12096 
  def read(self, iprot):
12097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12099 
      return
12100 
    iprot.readStructBegin()
12101 
    while True:
12102 
      (fname, ftype, fid) = iprot.readFieldBegin()
12103 
      if ftype == TType.STOP:
12104 
        break
12105 
      if fid == 1:
12106 
        if ftype == TType.STRING:
12107 
          self.displayName = iprot.readString();
12108 
        else:
12109 
          iprot.skip(ftype)
12110 
      elif fid == 2:
12111 
        if ftype == TType.I64:
12112 
          self.itemId = iprot.readI64();
12113 
        else:
12114 
          iprot.skip(ftype)
12115 
      else:
12116 
        iprot.skip(ftype)
12117 
      iprot.readFieldEnd()
12118 
    iprot.readStructEnd()
12119 
 
12120 
  def write(self, oprot):
12121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12123 
      return
12124 
    oprot.writeStructBegin('addTag_args')
12125 
    if self.displayName is not None:
12126 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12127 
      oprot.writeString(self.displayName)
12128 
      oprot.writeFieldEnd()
12129 
    if self.itemId is not None:
12130 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12131 
      oprot.writeI64(self.itemId)
12132 
      oprot.writeFieldEnd()
12133 
    oprot.writeFieldStop()
12134 
    oprot.writeStructEnd()
12135 
 
12136 
  def validate(self):
12137 
    return
12138 
 
12139 
 
12140 
  def __repr__(self):
12141 
    L = ['%s=%r' % (key, value)
12142 
      for key, value in self.__dict__.iteritems()]
12143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12144 
 
12145 
  def __eq__(self, other):
12146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12147 
 
12148 
  def __ne__(self, other):
12149 
    return not (self == other)
12150 
 
12151 
class addTag_result:
12152 
  """
12153 
  Attributes:
12154 
   - success
12155 
  """
12156 
 
12157 
  thrift_spec = (
12158 
    (0, TType.BOOL, 'success', None, None, ), # 0
12159 
  )
12160 
 
12161 
  def __init__(self, success=None,):
12162 
    self.success = success
12163 
 
12164 
  def read(self, iprot):
12165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12167 
      return
12168 
    iprot.readStructBegin()
12169 
    while True:
12170 
      (fname, ftype, fid) = iprot.readFieldBegin()
12171 
      if ftype == TType.STOP:
12172 
        break
12173 
      if fid == 0:
12174 
        if ftype == TType.BOOL:
12175 
          self.success = iprot.readBool();
12176 
        else:
12177 
          iprot.skip(ftype)
12178 
      else:
12179 
        iprot.skip(ftype)
12180 
      iprot.readFieldEnd()
12181 
    iprot.readStructEnd()
12182 
 
12183 
  def write(self, oprot):
12184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12186 
      return
12187 
    oprot.writeStructBegin('addTag_result')
12188 
    if self.success is not None:
12189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12190 
      oprot.writeBool(self.success)
12191 
      oprot.writeFieldEnd()
12192 
    oprot.writeFieldStop()
12193 
    oprot.writeStructEnd()
12194 
 
12195 
  def validate(self):
12196 
    return
12197 
 
12198 
 
12199 
  def __repr__(self):
12200 
    L = ['%s=%r' % (key, value)
12201 
      for key, value in self.__dict__.iteritems()]
12202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12203 
 
12204 
  def __eq__(self, other):
12205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12206 
 
12207 
  def __ne__(self, other):
12208 
    return not (self == other)
12209 
 
12210 
class deleteEntityTag_args:
12211 
  """
12212 
  Attributes:
12213 
   - displayName
12214 
   - itemId
12215 
  """
12216 
 
12217 
  thrift_spec = (
12218 
    None, # 0
12219 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12220 
    (2, TType.I64, 'itemId', None, None, ), # 2
12221 
  )
12222 
 
12223 
  def __init__(self, displayName=None, itemId=None,):
12224 
    self.displayName = displayName
12225 
    self.itemId = itemId
12226 
 
12227 
  def read(self, iprot):
12228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12230 
      return
12231 
    iprot.readStructBegin()
12232 
    while True:
12233 
      (fname, ftype, fid) = iprot.readFieldBegin()
12234 
      if ftype == TType.STOP:
12235 
        break
12236 
      if fid == 1:
12237 
        if ftype == TType.STRING:
12238 
          self.displayName = iprot.readString();
12239 
        else:
12240 
          iprot.skip(ftype)
12241 
      elif fid == 2:
12242 
        if ftype == TType.I64:
12243 
          self.itemId = iprot.readI64();
12244 
        else:
12245 
          iprot.skip(ftype)
12246 
      else:
12247 
        iprot.skip(ftype)
12248 
      iprot.readFieldEnd()
12249 
    iprot.readStructEnd()
12250 
 
12251 
  def write(self, oprot):
12252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12254 
      return
12255 
    oprot.writeStructBegin('deleteEntityTag_args')
12256 
    if self.displayName is not None:
12257 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12258 
      oprot.writeString(self.displayName)
12259 
      oprot.writeFieldEnd()
12260 
    if self.itemId is not None:
12261 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12262 
      oprot.writeI64(self.itemId)
12263 
      oprot.writeFieldEnd()
12264 
    oprot.writeFieldStop()
12265 
    oprot.writeStructEnd()
12266 
 
12267 
  def validate(self):
12268 
    return
12269 
 
12270 
 
12271 
  def __repr__(self):
12272 
    L = ['%s=%r' % (key, value)
12273 
      for key, value in self.__dict__.iteritems()]
12274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12275 
 
12276 
  def __eq__(self, other):
12277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12278 
 
12279 
  def __ne__(self, other):
12280 
    return not (self == other)
12281 
 
12282 
class deleteEntityTag_result:
12283 
  """
12284 
  Attributes:
12285 
   - success
12286 
  """
12287 
 
12288 
  thrift_spec = (
12289 
    (0, TType.BOOL, 'success', None, None, ), # 0
12290 
  )
12291 
 
12292 
  def __init__(self, success=None,):
12293 
    self.success = success
12294 
 
12295 
  def read(self, iprot):
12296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12298 
      return
12299 
    iprot.readStructBegin()
12300 
    while True:
12301 
      (fname, ftype, fid) = iprot.readFieldBegin()
12302 
      if ftype == TType.STOP:
12303 
        break
12304 
      if fid == 0:
12305 
        if ftype == TType.BOOL:
12306 
          self.success = iprot.readBool();
12307 
        else:
12308 
          iprot.skip(ftype)
12309 
      else:
12310 
        iprot.skip(ftype)
12311 
      iprot.readFieldEnd()
12312 
    iprot.readStructEnd()
12313 
 
12314 
  def write(self, oprot):
12315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12317 
      return
12318 
    oprot.writeStructBegin('deleteEntityTag_result')
12319 
    if self.success is not None:
12320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12321 
      oprot.writeBool(self.success)
12322 
      oprot.writeFieldEnd()
12323 
    oprot.writeFieldStop()
12324 
    oprot.writeStructEnd()
12325 
 
12326 
  def validate(self):
12327 
    return
12328 
 
12329 
 
12330 
  def __repr__(self):
12331 
    L = ['%s=%r' % (key, value)
12332 
      for key, value in self.__dict__.iteritems()]
12333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12334 
 
12335 
  def __eq__(self, other):
12336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12337 
 
12338 
  def __ne__(self, other):
12339 
    return not (self == other)
12340 
 
12341 
class deleteTag_args:
12342 
  """
12343 
  Attributes:
12344 
   - displayName
12345 
  """
12346 
 
12347 
  thrift_spec = (
12348 
    None, # 0
12349 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12350 
  )
12351 
 
12352 
  def __init__(self, displayName=None,):
12353 
    self.displayName = displayName
12354 
 
12355 
  def read(self, iprot):
12356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12358 
      return
12359 
    iprot.readStructBegin()
12360 
    while True:
12361 
      (fname, ftype, fid) = iprot.readFieldBegin()
12362 
      if ftype == TType.STOP:
12363 
        break
12364 
      if fid == 1:
12365 
        if ftype == TType.STRING:
12366 
          self.displayName = iprot.readString();
12367 
        else:
12368 
          iprot.skip(ftype)
12369 
      else:
12370 
        iprot.skip(ftype)
12371 
      iprot.readFieldEnd()
12372 
    iprot.readStructEnd()
12373 
 
12374 
  def write(self, oprot):
12375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12377 
      return
12378 
    oprot.writeStructBegin('deleteTag_args')
12379 
    if self.displayName is not None:
12380 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12381 
      oprot.writeString(self.displayName)
12382 
      oprot.writeFieldEnd()
12383 
    oprot.writeFieldStop()
12384 
    oprot.writeStructEnd()
12385 
 
12386 
  def validate(self):
12387 
    return
12388 
 
12389 
 
12390 
  def __repr__(self):
12391 
    L = ['%s=%r' % (key, value)
12392 
      for key, value in self.__dict__.iteritems()]
12393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12394 
 
12395 
  def __eq__(self, other):
12396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12397 
 
12398 
  def __ne__(self, other):
12399 
    return not (self == other)
12400 
 
12401 
class deleteTag_result:
12402 
  """
12403 
  Attributes:
12404 
   - success
12405 
  """
12406 
 
12407 
  thrift_spec = (
12408 
    (0, TType.BOOL, 'success', None, None, ), # 0
12409 
  )
12410 
 
12411 
  def __init__(self, success=None,):
12412 
    self.success = success
12413 
 
12414 
  def read(self, iprot):
12415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12417 
      return
12418 
    iprot.readStructBegin()
12419 
    while True:
12420 
      (fname, ftype, fid) = iprot.readFieldBegin()
12421 
      if ftype == TType.STOP:
12422 
        break
12423 
      if fid == 0:
12424 
        if ftype == TType.BOOL:
12425 
          self.success = iprot.readBool();
12426 
        else:
12427 
          iprot.skip(ftype)
12428 
      else:
12429 
        iprot.skip(ftype)
12430 
      iprot.readFieldEnd()
12431 
    iprot.readStructEnd()
12432 
 
12433 
  def write(self, oprot):
12434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12436 
      return
12437 
    oprot.writeStructBegin('deleteTag_result')
12438 
    if self.success is not None:
12439 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12440 
      oprot.writeBool(self.success)
12441 
      oprot.writeFieldEnd()
12442 
    oprot.writeFieldStop()
12443 
    oprot.writeStructEnd()
12444 
 
12445 
  def validate(self):
12446 
    return
12447 
 
12448 
 
12449 
  def __repr__(self):
12450 
    L = ['%s=%r' % (key, value)
12451 
      for key, value in self.__dict__.iteritems()]
12452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12453 
 
12454 
  def __eq__(self, other):
12455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12456 
 
12457 
  def __ne__(self, other):
12458 
    return not (self == other)
12459 
 
12460 
class getAllTags_args:
12461 
 
12462 
  thrift_spec = (
12463 
  )
12464 
 
12465 
  def read(self, iprot):
12466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12468 
      return
12469 
    iprot.readStructBegin()
12470 
    while True:
12471 
      (fname, ftype, fid) = iprot.readFieldBegin()
12472 
      if ftype == TType.STOP:
12473 
        break
12474 
      else:
12475 
        iprot.skip(ftype)
12476 
      iprot.readFieldEnd()
12477 
    iprot.readStructEnd()
12478 
 
12479 
  def write(self, oprot):
12480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12482 
      return
12483 
    oprot.writeStructBegin('getAllTags_args')
12484 
    oprot.writeFieldStop()
12485 
    oprot.writeStructEnd()
12486 
 
12487 
  def validate(self):
12488 
    return
12489 
 
12490 
 
12491 
  def __repr__(self):
12492 
    L = ['%s=%r' % (key, value)
12493 
      for key, value in self.__dict__.iteritems()]
12494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12495 
 
12496 
  def __eq__(self, other):
12497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12498 
 
12499 
  def __ne__(self, other):
12500 
    return not (self == other)
12501 
 
12502 
class getAllTags_result:
12503 
  """
12504 
  Attributes:
12505 
   - success
12506 
  """
12507 
 
12508 
  thrift_spec = (
12509 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12510 
  )
12511 
 
12512 
  def __init__(self, success=None,):
12513 
    self.success = success
12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 0:
12525 
        if ftype == TType.LIST:
12526 
          self.success = []
8590 kshitij.so 12527 
          (_etype168, _size165) = iprot.readListBegin()
12528 
          for _i169 in xrange(_size165):
12529 
            _elem170 = iprot.readString();
12530 
            self.success.append(_elem170)
6512 kshitij.so 12531 
          iprot.readListEnd()
12532 
        else:
12533 
          iprot.skip(ftype)
12534 
      else:
12535 
        iprot.skip(ftype)
12536 
      iprot.readFieldEnd()
12537 
    iprot.readStructEnd()
12538 
 
12539 
  def write(self, oprot):
12540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12542 
      return
12543 
    oprot.writeStructBegin('getAllTags_result')
12544 
    if self.success is not None:
12545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12546 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12547 
      for iter171 in self.success:
12548 
        oprot.writeString(iter171)
6512 kshitij.so 12549 
      oprot.writeListEnd()
12550 
      oprot.writeFieldEnd()
12551 
    oprot.writeFieldStop()
12552 
    oprot.writeStructEnd()
12553 
 
12554 
  def validate(self):
12555 
    return
12556 
 
12557 
 
12558 
  def __repr__(self):
12559 
    L = ['%s=%r' % (key, value)
12560 
      for key, value in self.__dict__.iteritems()]
12561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12562 
 
12563 
  def __eq__(self, other):
12564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12565 
 
12566 
  def __ne__(self, other):
12567 
    return not (self == other)
12568 
 
12569 
class getAllEntitiesByTagName_args:
12570 
  """
12571 
  Attributes:
12572 
   - displayName
12573 
  """
12574 
 
12575 
  thrift_spec = (
12576 
    None, # 0
12577 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12578 
  )
12579 
 
12580 
  def __init__(self, displayName=None,):
12581 
    self.displayName = displayName
12582 
 
12583 
  def read(self, iprot):
12584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12586 
      return
12587 
    iprot.readStructBegin()
12588 
    while True:
12589 
      (fname, ftype, fid) = iprot.readFieldBegin()
12590 
      if ftype == TType.STOP:
12591 
        break
12592 
      if fid == 1:
12593 
        if ftype == TType.STRING:
12594 
          self.displayName = iprot.readString();
12595 
        else:
12596 
          iprot.skip(ftype)
12597 
      else:
12598 
        iprot.skip(ftype)
12599 
      iprot.readFieldEnd()
12600 
    iprot.readStructEnd()
12601 
 
12602 
  def write(self, oprot):
12603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12605 
      return
12606 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12607 
    if self.displayName is not None:
12608 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12609 
      oprot.writeString(self.displayName)
12610 
      oprot.writeFieldEnd()
12611 
    oprot.writeFieldStop()
12612 
    oprot.writeStructEnd()
12613 
 
12614 
  def validate(self):
12615 
    return
12616 
 
12617 
 
12618 
  def __repr__(self):
12619 
    L = ['%s=%r' % (key, value)
12620 
      for key, value in self.__dict__.iteritems()]
12621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12622 
 
12623 
  def __eq__(self, other):
12624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12625 
 
12626 
  def __ne__(self, other):
12627 
    return not (self == other)
12628 
 
12629 
class getAllEntitiesByTagName_result:
12630 
  """
12631 
  Attributes:
12632 
   - success
12633 
  """
12634 
 
12635 
  thrift_spec = (
12636 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12637 
  )
12638 
 
12639 
  def __init__(self, success=None,):
12640 
    self.success = success
12641 
 
12642 
  def read(self, iprot):
12643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12645 
      return
12646 
    iprot.readStructBegin()
12647 
    while True:
12648 
      (fname, ftype, fid) = iprot.readFieldBegin()
12649 
      if ftype == TType.STOP:
12650 
        break
12651 
      if fid == 0:
12652 
        if ftype == TType.LIST:
12653 
          self.success = []
8590 kshitij.so 12654 
          (_etype175, _size172) = iprot.readListBegin()
12655 
          for _i176 in xrange(_size172):
12656 
            _elem177 = iprot.readI64();
12657 
            self.success.append(_elem177)
6512 kshitij.so 12658 
          iprot.readListEnd()
12659 
        else:
12660 
          iprot.skip(ftype)
12661 
      else:
12662 
        iprot.skip(ftype)
12663 
      iprot.readFieldEnd()
12664 
    iprot.readStructEnd()
12665 
 
12666 
  def write(self, oprot):
12667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12669 
      return
12670 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12671 
    if self.success is not None:
12672 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12673 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12674 
      for iter178 in self.success:
12675 
        oprot.writeI64(iter178)
6512 kshitij.so 12676 
      oprot.writeListEnd()
12677 
      oprot.writeFieldEnd()
12678 
    oprot.writeFieldStop()
12679 
    oprot.writeStructEnd()
12680 
 
12681 
  def validate(self):
12682 
    return
12683 
 
12684 
 
12685 
  def __repr__(self):
12686 
    L = ['%s=%r' % (key, value)
12687 
      for key, value in self.__dict__.iteritems()]
12688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12689 
 
12690 
  def __eq__(self, other):
12691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12692 
 
12693 
  def __ne__(self, other):
12694 
    return not (self == other)
12695 
 
6845 amit.gupta 12696 
class getAllEntityTags_args:
12697 
 
12698 
  thrift_spec = (
12699 
  )
12700 
 
12701 
  def read(self, iprot):
12702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12704 
      return
12705 
    iprot.readStructBegin()
12706 
    while True:
12707 
      (fname, ftype, fid) = iprot.readFieldBegin()
12708 
      if ftype == TType.STOP:
12709 
        break
12710 
      else:
12711 
        iprot.skip(ftype)
12712 
      iprot.readFieldEnd()
12713 
    iprot.readStructEnd()
12714 
 
12715 
  def write(self, oprot):
12716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12718 
      return
12719 
    oprot.writeStructBegin('getAllEntityTags_args')
12720 
    oprot.writeFieldStop()
12721 
    oprot.writeStructEnd()
12722 
 
12723 
  def validate(self):
12724 
    return
12725 
 
12726 
 
12727 
  def __repr__(self):
12728 
    L = ['%s=%r' % (key, value)
12729 
      for key, value in self.__dict__.iteritems()]
12730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12731 
 
12732 
  def __eq__(self, other):
12733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12734 
 
12735 
  def __ne__(self, other):
12736 
    return not (self == other)
12737 
 
12738 
class getAllEntityTags_result:
12739 
  """
12740 
  Attributes:
12741 
   - success
12742 
  """
12743 
 
12744 
  thrift_spec = (
12745 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12746 
  )
12747 
 
12748 
  def __init__(self, success=None,):
12749 
    self.success = success
12750 
 
12751 
  def read(self, iprot):
12752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12754 
      return
12755 
    iprot.readStructBegin()
12756 
    while True:
12757 
      (fname, ftype, fid) = iprot.readFieldBegin()
12758 
      if ftype == TType.STOP:
12759 
        break
12760 
      if fid == 0:
12761 
        if ftype == TType.MAP:
12762 
          self.success = {}
8590 kshitij.so 12763 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12764 
          for _i183 in xrange(_size179):
12765 
            _key184 = iprot.readI64();
12766 
            _val185 = []
12767 
            (_etype189, _size186) = iprot.readListBegin()
12768 
            for _i190 in xrange(_size186):
12769 
              _elem191 = iprot.readString();
12770 
              _val185.append(_elem191)
6845 amit.gupta 12771 
            iprot.readListEnd()
8590 kshitij.so 12772 
            self.success[_key184] = _val185
6845 amit.gupta 12773 
          iprot.readMapEnd()
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      else:
12777 
        iprot.skip(ftype)
12778 
      iprot.readFieldEnd()
12779 
    iprot.readStructEnd()
12780 
 
12781 
  def write(self, oprot):
12782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12784 
      return
12785 
    oprot.writeStructBegin('getAllEntityTags_result')
12786 
    if self.success is not None:
12787 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12788 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12789 
      for kiter192,viter193 in self.success.items():
12790 
        oprot.writeI64(kiter192)
12791 
        oprot.writeListBegin(TType.STRING, len(viter193))
12792 
        for iter194 in viter193:
12793 
          oprot.writeString(iter194)
6845 amit.gupta 12794 
        oprot.writeListEnd()
12795 
      oprot.writeMapEnd()
12796 
      oprot.writeFieldEnd()
12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
6850 kshitij.so 12815 
class addBanner_args:
12816 
  """
12817 
  Attributes:
8590 kshitij.so 12818 
   - bannerCongregate
6850 kshitij.so 12819 
  """
12820 
 
12821 
  thrift_spec = (
12822 
    None, # 0
8590 kshitij.so 12823 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12824 
  )
12825 
 
8590 kshitij.so 12826 
  def __init__(self, bannerCongregate=None,):
12827 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12828 
 
12829 
  def read(self, iprot):
12830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12832 
      return
12833 
    iprot.readStructBegin()
12834 
    while True:
12835 
      (fname, ftype, fid) = iprot.readFieldBegin()
12836 
      if ftype == TType.STOP:
12837 
        break
12838 
      if fid == 1:
8579 kshitij.so 12839 
        if ftype == TType.STRUCT:
8590 kshitij.so 12840 
          self.bannerCongregate = BannerCongregate()
12841 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12842 
        else:
12843 
          iprot.skip(ftype)
8579 kshitij.so 12844 
      else:
12845 
        iprot.skip(ftype)
12846 
      iprot.readFieldEnd()
12847 
    iprot.readStructEnd()
12848 
 
12849 
  def write(self, oprot):
12850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12852 
      return
12853 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12854 
    if self.bannerCongregate is not None:
12855 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12856 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12857 
      oprot.writeFieldEnd()
12858 
    oprot.writeFieldStop()
12859 
    oprot.writeStructEnd()
12860 
 
12861 
  def validate(self):
12862 
    return
12863 
 
12864 
 
12865 
  def __repr__(self):
12866 
    L = ['%s=%r' % (key, value)
12867 
      for key, value in self.__dict__.iteritems()]
12868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12869 
 
12870 
  def __eq__(self, other):
12871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12872 
 
12873 
  def __ne__(self, other):
12874 
    return not (self == other)
12875 
 
12876 
class addBanner_result:
12877 
 
12878 
  thrift_spec = (
12879 
  )
12880 
 
12881 
  def read(self, iprot):
12882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12884 
      return
12885 
    iprot.readStructBegin()
12886 
    while True:
12887 
      (fname, ftype, fid) = iprot.readFieldBegin()
12888 
      if ftype == TType.STOP:
12889 
        break
12890 
      else:
12891 
        iprot.skip(ftype)
12892 
      iprot.readFieldEnd()
12893 
    iprot.readStructEnd()
12894 
 
12895 
  def write(self, oprot):
12896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12898 
      return
12899 
    oprot.writeStructBegin('addBanner_result')
12900 
    oprot.writeFieldStop()
12901 
    oprot.writeStructEnd()
12902 
 
12903 
  def validate(self):
12904 
    return
12905 
 
12906 
 
12907 
  def __repr__(self):
12908 
    L = ['%s=%r' % (key, value)
12909 
      for key, value in self.__dict__.iteritems()]
12910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12911 
 
12912 
  def __eq__(self, other):
12913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12914 
 
12915 
  def __ne__(self, other):
12916 
    return not (self == other)
12917 
 
12918 
class updateBanner_args:
12919 
  """
12920 
  Attributes:
12921 
   - banner
12922 
  """
12923 
 
12924 
  thrift_spec = (
12925 
    None, # 0
12926 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12927 
  )
12928 
 
12929 
  def __init__(self, banner=None,):
12930 
    self.banner = banner
12931 
 
12932 
  def read(self, iprot):
12933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12935 
      return
12936 
    iprot.readStructBegin()
12937 
    while True:
12938 
      (fname, ftype, fid) = iprot.readFieldBegin()
12939 
      if ftype == TType.STOP:
12940 
        break
12941 
      if fid == 1:
12942 
        if ftype == TType.STRUCT:
12943 
          self.banner = Banner()
12944 
          self.banner.read(iprot)
6850 kshitij.so 12945 
        else:
12946 
          iprot.skip(ftype)
12947 
      else:
12948 
        iprot.skip(ftype)
12949 
      iprot.readFieldEnd()
12950 
    iprot.readStructEnd()
12951 
 
12952 
  def write(self, oprot):
12953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12955 
      return
8579 kshitij.so 12956 
    oprot.writeStructBegin('updateBanner_args')
12957 
    if self.banner is not None:
12958 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12959 
      self.banner.write(oprot)
6850 kshitij.so 12960 
      oprot.writeFieldEnd()
12961 
    oprot.writeFieldStop()
12962 
    oprot.writeStructEnd()
12963 
 
12964 
  def validate(self):
12965 
    return
12966 
 
12967 
 
12968 
  def __repr__(self):
12969 
    L = ['%s=%r' % (key, value)
12970 
      for key, value in self.__dict__.iteritems()]
12971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12972 
 
12973 
  def __eq__(self, other):
12974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12975 
 
12976 
  def __ne__(self, other):
12977 
    return not (self == other)
12978 
 
8579 kshitij.so 12979 
class updateBanner_result:
6850 kshitij.so 12980 
  """
12981 
  Attributes:
12982 
   - success
12983 
  """
12984 
 
12985 
  thrift_spec = (
12986 
    (0, TType.BOOL, 'success', None, None, ), # 0
12987 
  )
12988 
 
12989 
  def __init__(self, success=None,):
12990 
    self.success = success
12991 
 
12992 
  def read(self, iprot):
12993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12995 
      return
12996 
    iprot.readStructBegin()
12997 
    while True:
12998 
      (fname, ftype, fid) = iprot.readFieldBegin()
12999 
      if ftype == TType.STOP:
13000 
        break
13001 
      if fid == 0:
13002 
        if ftype == TType.BOOL:
13003 
          self.success = iprot.readBool();
13004 
        else:
13005 
          iprot.skip(ftype)
13006 
      else:
13007 
        iprot.skip(ftype)
13008 
      iprot.readFieldEnd()
13009 
    iprot.readStructEnd()
13010 
 
13011 
  def write(self, oprot):
13012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13014 
      return
8579 kshitij.so 13015 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13016 
    if self.success is not None:
13017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13018 
      oprot.writeBool(self.success)
13019 
      oprot.writeFieldEnd()
13020 
    oprot.writeFieldStop()
13021 
    oprot.writeStructEnd()
13022 
 
13023 
  def validate(self):
13024 
    return
13025 
 
13026 
 
13027 
  def __repr__(self):
13028 
    L = ['%s=%r' % (key, value)
13029 
      for key, value in self.__dict__.iteritems()]
13030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13031 
 
13032 
  def __eq__(self, other):
13033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13034 
 
13035 
  def __ne__(self, other):
13036 
    return not (self == other)
13037 
 
13038 
class getAllBanners_args:
13039 
 
13040 
  thrift_spec = (
13041 
  )
13042 
 
13043 
  def read(self, iprot):
13044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13046 
      return
13047 
    iprot.readStructBegin()
13048 
    while True:
13049 
      (fname, ftype, fid) = iprot.readFieldBegin()
13050 
      if ftype == TType.STOP:
13051 
        break
13052 
      else:
13053 
        iprot.skip(ftype)
13054 
      iprot.readFieldEnd()
13055 
    iprot.readStructEnd()
13056 
 
13057 
  def write(self, oprot):
13058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13060 
      return
13061 
    oprot.writeStructBegin('getAllBanners_args')
13062 
    oprot.writeFieldStop()
13063 
    oprot.writeStructEnd()
13064 
 
13065 
  def validate(self):
13066 
    return
13067 
 
13068 
 
13069 
  def __repr__(self):
13070 
    L = ['%s=%r' % (key, value)
13071 
      for key, value in self.__dict__.iteritems()]
13072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13073 
 
13074 
  def __eq__(self, other):
13075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13076 
 
13077 
  def __ne__(self, other):
13078 
    return not (self == other)
13079 
 
13080 
class getAllBanners_result:
13081 
  """
13082 
  Attributes:
13083 
   - success
13084 
  """
13085 
 
13086 
  thrift_spec = (
8579 kshitij.so 13087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13088 
  )
13089 
 
13090 
  def __init__(self, success=None,):
13091 
    self.success = success
13092 
 
13093 
  def read(self, iprot):
13094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13096 
      return
13097 
    iprot.readStructBegin()
13098 
    while True:
13099 
      (fname, ftype, fid) = iprot.readFieldBegin()
13100 
      if ftype == TType.STOP:
13101 
        break
13102 
      if fid == 0:
13103 
        if ftype == TType.LIST:
13104 
          self.success = []
8590 kshitij.so 13105 
          (_etype198, _size195) = iprot.readListBegin()
13106 
          for _i199 in xrange(_size195):
13107 
            _elem200 = Banner()
13108 
            _elem200.read(iprot)
13109 
            self.success.append(_elem200)
6850 kshitij.so 13110 
          iprot.readListEnd()
13111 
        else:
13112 
          iprot.skip(ftype)
13113 
      else:
13114 
        iprot.skip(ftype)
13115 
      iprot.readFieldEnd()
13116 
    iprot.readStructEnd()
13117 
 
13118 
  def write(self, oprot):
13119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13121 
      return
13122 
    oprot.writeStructBegin('getAllBanners_result')
13123 
    if self.success is not None:
13124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13126 
      for iter201 in self.success:
13127 
        iter201.write(oprot)
6850 kshitij.so 13128 
      oprot.writeListEnd()
13129 
      oprot.writeFieldEnd()
13130 
    oprot.writeFieldStop()
13131 
    oprot.writeStructEnd()
13132 
 
13133 
  def validate(self):
13134 
    return
13135 
 
13136 
 
13137 
  def __repr__(self):
13138 
    L = ['%s=%r' % (key, value)
13139 
      for key, value in self.__dict__.iteritems()]
13140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13141 
 
13142 
  def __eq__(self, other):
13143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13144 
 
13145 
  def __ne__(self, other):
13146 
    return not (self == other)
13147 
 
13148 
class deleteBanner_args:
13149 
  """
13150 
  Attributes:
13151 
   - bannerName
9155 kshitij.so 13152 
   - bannerType
6850 kshitij.so 13153 
  """
13154 
 
13155 
  thrift_spec = (
13156 
    None, # 0
13157 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13158 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13159 
  )
13160 
 
9155 kshitij.so 13161 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13162 
    self.bannerName = bannerName
9155 kshitij.so 13163 
    self.bannerType = bannerType
6850 kshitij.so 13164 
 
13165 
  def read(self, iprot):
13166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13168 
      return
13169 
    iprot.readStructBegin()
13170 
    while True:
13171 
      (fname, ftype, fid) = iprot.readFieldBegin()
13172 
      if ftype == TType.STOP:
13173 
        break
13174 
      if fid == 1:
13175 
        if ftype == TType.STRING:
13176 
          self.bannerName = iprot.readString();
13177 
        else:
13178 
          iprot.skip(ftype)
9155 kshitij.so 13179 
      elif fid == 2:
13180 
        if ftype == TType.I32:
13181 
          self.bannerType = iprot.readI32();
13182 
        else:
13183 
          iprot.skip(ftype)
6850 kshitij.so 13184 
      else:
13185 
        iprot.skip(ftype)
13186 
      iprot.readFieldEnd()
13187 
    iprot.readStructEnd()
13188 
 
13189 
  def write(self, oprot):
13190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13192 
      return
13193 
    oprot.writeStructBegin('deleteBanner_args')
13194 
    if self.bannerName is not None:
13195 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13196 
      oprot.writeString(self.bannerName)
13197 
      oprot.writeFieldEnd()
9155 kshitij.so 13198 
    if self.bannerType is not None:
13199 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13200 
      oprot.writeI32(self.bannerType)
13201 
      oprot.writeFieldEnd()
6850 kshitij.so 13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
13220 
class deleteBanner_result:
13221 
  """
13222 
  Attributes:
13223 
   - success
13224 
  """
13225 
 
13226 
  thrift_spec = (
13227 
    (0, TType.BOOL, 'success', None, None, ), # 0
13228 
  )
13229 
 
13230 
  def __init__(self, success=None,):
13231 
    self.success = success
13232 
 
13233 
  def read(self, iprot):
13234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13236 
      return
13237 
    iprot.readStructBegin()
13238 
    while True:
13239 
      (fname, ftype, fid) = iprot.readFieldBegin()
13240 
      if ftype == TType.STOP:
13241 
        break
13242 
      if fid == 0:
13243 
        if ftype == TType.BOOL:
13244 
          self.success = iprot.readBool();
13245 
        else:
13246 
          iprot.skip(ftype)
13247 
      else:
13248 
        iprot.skip(ftype)
13249 
      iprot.readFieldEnd()
13250 
    iprot.readStructEnd()
13251 
 
13252 
  def write(self, oprot):
13253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13255 
      return
13256 
    oprot.writeStructBegin('deleteBanner_result')
13257 
    if self.success is not None:
13258 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13259 
      oprot.writeBool(self.success)
13260 
      oprot.writeFieldEnd()
13261 
    oprot.writeFieldStop()
13262 
    oprot.writeStructEnd()
13263 
 
13264 
  def validate(self):
13265 
    return
13266 
 
13267 
 
13268 
  def __repr__(self):
13269 
    L = ['%s=%r' % (key, value)
13270 
      for key, value in self.__dict__.iteritems()]
13271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13272 
 
13273 
  def __eq__(self, other):
13274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13275 
 
13276 
  def __ne__(self, other):
13277 
    return not (self == other)
13278 
 
13279 
class getBannerDetails_args:
13280 
  """
13281 
  Attributes:
13282 
   - bannerName
9155 kshitij.so 13283 
   - bannerType
6850 kshitij.so 13284 
  """
13285 
 
13286 
  thrift_spec = (
13287 
    None, # 0
13288 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13289 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13290 
  )
13291 
 
9155 kshitij.so 13292 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13293 
    self.bannerName = bannerName
9155 kshitij.so 13294 
    self.bannerType = bannerType
6850 kshitij.so 13295 
 
13296 
  def read(self, iprot):
13297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13299 
      return
13300 
    iprot.readStructBegin()
13301 
    while True:
13302 
      (fname, ftype, fid) = iprot.readFieldBegin()
13303 
      if ftype == TType.STOP:
13304 
        break
13305 
      if fid == 1:
13306 
        if ftype == TType.STRING:
13307 
          self.bannerName = iprot.readString();
13308 
        else:
13309 
          iprot.skip(ftype)
9155 kshitij.so 13310 
      elif fid == 2:
13311 
        if ftype == TType.I32:
13312 
          self.bannerType = iprot.readI32();
13313 
        else:
13314 
          iprot.skip(ftype)
6850 kshitij.so 13315 
      else:
13316 
        iprot.skip(ftype)
13317 
      iprot.readFieldEnd()
13318 
    iprot.readStructEnd()
13319 
 
13320 
  def write(self, oprot):
13321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13323 
      return
13324 
    oprot.writeStructBegin('getBannerDetails_args')
13325 
    if self.bannerName is not None:
13326 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13327 
      oprot.writeString(self.bannerName)
13328 
      oprot.writeFieldEnd()
9155 kshitij.so 13329 
    if self.bannerType is not None:
13330 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13331 
      oprot.writeI32(self.bannerType)
13332 
      oprot.writeFieldEnd()
6850 kshitij.so 13333 
    oprot.writeFieldStop()
13334 
    oprot.writeStructEnd()
13335 
 
13336 
  def validate(self):
13337 
    return
13338 
 
13339 
 
13340 
  def __repr__(self):
13341 
    L = ['%s=%r' % (key, value)
13342 
      for key, value in self.__dict__.iteritems()]
13343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13344 
 
13345 
  def __eq__(self, other):
13346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13347 
 
13348 
  def __ne__(self, other):
13349 
    return not (self == other)
13350 
 
13351 
class getBannerDetails_result:
13352 
  """
13353 
  Attributes:
13354 
   - success
13355 
  """
13356 
 
13357 
  thrift_spec = (
13358 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13359 
  )
13360 
 
13361 
  def __init__(self, success=None,):
13362 
    self.success = success
13363 
 
13364 
  def read(self, iprot):
13365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13367 
      return
13368 
    iprot.readStructBegin()
13369 
    while True:
13370 
      (fname, ftype, fid) = iprot.readFieldBegin()
13371 
      if ftype == TType.STOP:
13372 
        break
13373 
      if fid == 0:
13374 
        if ftype == TType.STRUCT:
13375 
          self.success = Banner()
13376 
          self.success.read(iprot)
13377 
        else:
13378 
          iprot.skip(ftype)
13379 
      else:
13380 
        iprot.skip(ftype)
13381 
      iprot.readFieldEnd()
13382 
    iprot.readStructEnd()
13383 
 
13384 
  def write(self, oprot):
13385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13387 
      return
13388 
    oprot.writeStructBegin('getBannerDetails_result')
13389 
    if self.success is not None:
13390 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13391 
      self.success.write(oprot)
13392 
      oprot.writeFieldEnd()
13393 
    oprot.writeFieldStop()
13394 
    oprot.writeStructEnd()
13395 
 
13396 
  def validate(self):
13397 
    return
13398 
 
13399 
 
13400 
  def __repr__(self):
13401 
    L = ['%s=%r' % (key, value)
13402 
      for key, value in self.__dict__.iteritems()]
13403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13404 
 
13405 
  def __eq__(self, other):
13406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13407 
 
13408 
  def __ne__(self, other):
13409 
    return not (self == other)
13410 
 
13411 
class getActiveBanners_args:
13412 
 
13413 
  thrift_spec = (
13414 
  )
13415 
 
13416 
  def read(self, iprot):
13417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13419 
      return
13420 
    iprot.readStructBegin()
13421 
    while True:
13422 
      (fname, ftype, fid) = iprot.readFieldBegin()
13423 
      if ftype == TType.STOP:
13424 
        break
13425 
      else:
13426 
        iprot.skip(ftype)
13427 
      iprot.readFieldEnd()
13428 
    iprot.readStructEnd()
13429 
 
13430 
  def write(self, oprot):
13431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13433 
      return
13434 
    oprot.writeStructBegin('getActiveBanners_args')
13435 
    oprot.writeFieldStop()
13436 
    oprot.writeStructEnd()
13437 
 
13438 
  def validate(self):
13439 
    return
13440 
 
13441 
 
13442 
  def __repr__(self):
13443 
    L = ['%s=%r' % (key, value)
13444 
      for key, value in self.__dict__.iteritems()]
13445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13446 
 
13447 
  def __eq__(self, other):
13448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13449 
 
13450 
  def __ne__(self, other):
13451 
    return not (self == other)
13452 
 
13453 
class getActiveBanners_result:
13454 
  """
13455 
  Attributes:
13456 
   - success
13457 
  """
13458 
 
13459 
  thrift_spec = (
8579 kshitij.so 13460 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13461 
  )
13462 
 
13463 
  def __init__(self, success=None,):
13464 
    self.success = success
13465 
 
13466 
  def read(self, iprot):
13467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13469 
      return
13470 
    iprot.readStructBegin()
13471 
    while True:
13472 
      (fname, ftype, fid) = iprot.readFieldBegin()
13473 
      if ftype == TType.STOP:
13474 
        break
13475 
      if fid == 0:
8579 kshitij.so 13476 
        if ftype == TType.MAP:
13477 
          self.success = {}
8590 kshitij.so 13478 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13479 
          for _i206 in xrange(_size202):
13480 
            _key207 = iprot.readString();
13481 
            _val208 = []
13482 
            (_etype212, _size209) = iprot.readListBegin()
13483 
            for _i213 in xrange(_size209):
13484 
              _elem214 = Banner()
13485 
              _elem214.read(iprot)
13486 
              _val208.append(_elem214)
8579 kshitij.so 13487 
            iprot.readListEnd()
8590 kshitij.so 13488 
            self.success[_key207] = _val208
8579 kshitij.so 13489 
          iprot.readMapEnd()
6850 kshitij.so 13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      else:
13493 
        iprot.skip(ftype)
13494 
      iprot.readFieldEnd()
13495 
    iprot.readStructEnd()
13496 
 
13497 
  def write(self, oprot):
13498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13500 
      return
13501 
    oprot.writeStructBegin('getActiveBanners_result')
13502 
    if self.success is not None:
8579 kshitij.so 13503 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13504 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13505 
      for kiter215,viter216 in self.success.items():
13506 
        oprot.writeString(kiter215)
13507 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13508 
        for iter217 in viter216:
13509 
          iter217.write(oprot)
8579 kshitij.so 13510 
        oprot.writeListEnd()
13511 
      oprot.writeMapEnd()
6850 kshitij.so 13512 
      oprot.writeFieldEnd()
13513 
    oprot.writeFieldStop()
13514 
    oprot.writeStructEnd()
13515 
 
13516 
  def validate(self):
13517 
    return
13518 
 
13519 
 
13520 
  def __repr__(self):
13521 
    L = ['%s=%r' % (key, value)
13522 
      for key, value in self.__dict__.iteritems()]
13523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13524 
 
13525 
  def __eq__(self, other):
13526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13527 
 
13528 
  def __ne__(self, other):
13529 
    return not (self == other)
13530 
 
6849 kshitij.so 13531 
class addBannerMap_args:
13532 
  """
13533 
  Attributes:
8579 kshitij.so 13534 
   - bannerMaps
6849 kshitij.so 13535 
  """
13536 
 
13537 
  thrift_spec = (
13538 
    None, # 0
8579 kshitij.so 13539 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13540 
  )
13541 
 
8579 kshitij.so 13542 
  def __init__(self, bannerMaps=None,):
13543 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13544 
 
13545 
  def read(self, iprot):
13546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13548 
      return
13549 
    iprot.readStructBegin()
13550 
    while True:
13551 
      (fname, ftype, fid) = iprot.readFieldBegin()
13552 
      if ftype == TType.STOP:
13553 
        break
13554 
      if fid == 1:
8579 kshitij.so 13555 
        if ftype == TType.LIST:
13556 
          self.bannerMaps = []
8590 kshitij.so 13557 
          (_etype221, _size218) = iprot.readListBegin()
13558 
          for _i222 in xrange(_size218):
13559 
            _elem223 = BannerMap()
13560 
            _elem223.read(iprot)
13561 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13562 
          iprot.readListEnd()
6849 kshitij.so 13563 
        else:
13564 
          iprot.skip(ftype)
8579 kshitij.so 13565 
      else:
13566 
        iprot.skip(ftype)
13567 
      iprot.readFieldEnd()
13568 
    iprot.readStructEnd()
13569 
 
13570 
  def write(self, oprot):
13571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13573 
      return
13574 
    oprot.writeStructBegin('addBannerMap_args')
13575 
    if self.bannerMaps is not None:
13576 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13577 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13578 
      for iter224 in self.bannerMaps:
13579 
        iter224.write(oprot)
8579 kshitij.so 13580 
      oprot.writeListEnd()
13581 
      oprot.writeFieldEnd()
13582 
    oprot.writeFieldStop()
13583 
    oprot.writeStructEnd()
13584 
 
13585 
  def validate(self):
13586 
    return
13587 
 
13588 
 
13589 
  def __repr__(self):
13590 
    L = ['%s=%r' % (key, value)
13591 
      for key, value in self.__dict__.iteritems()]
13592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13593 
 
13594 
  def __eq__(self, other):
13595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13596 
 
13597 
  def __ne__(self, other):
13598 
    return not (self == other)
13599 
 
13600 
class addBannerMap_result:
13601 
  """
13602 
  Attributes:
13603 
   - success
13604 
  """
13605 
 
13606 
  thrift_spec = (
13607 
    (0, TType.BOOL, 'success', None, None, ), # 0
13608 
  )
13609 
 
13610 
  def __init__(self, success=None,):
13611 
    self.success = success
13612 
 
13613 
  def read(self, iprot):
13614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13616 
      return
13617 
    iprot.readStructBegin()
13618 
    while True:
13619 
      (fname, ftype, fid) = iprot.readFieldBegin()
13620 
      if ftype == TType.STOP:
13621 
        break
13622 
      if fid == 0:
13623 
        if ftype == TType.BOOL:
13624 
          self.success = iprot.readBool();
6849 kshitij.so 13625 
        else:
13626 
          iprot.skip(ftype)
8579 kshitij.so 13627 
      else:
13628 
        iprot.skip(ftype)
13629 
      iprot.readFieldEnd()
13630 
    iprot.readStructEnd()
13631 
 
13632 
  def write(self, oprot):
13633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13635 
      return
13636 
    oprot.writeStructBegin('addBannerMap_result')
13637 
    if self.success is not None:
13638 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13639 
      oprot.writeBool(self.success)
13640 
      oprot.writeFieldEnd()
13641 
    oprot.writeFieldStop()
13642 
    oprot.writeStructEnd()
13643 
 
13644 
  def validate(self):
13645 
    return
13646 
 
13647 
 
13648 
  def __repr__(self):
13649 
    L = ['%s=%r' % (key, value)
13650 
      for key, value in self.__dict__.iteritems()]
13651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13652 
 
13653 
  def __eq__(self, other):
13654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13655 
 
13656 
  def __ne__(self, other):
13657 
    return not (self == other)
13658 
 
13659 
class updateBannerMap_args:
13660 
  """
13661 
  Attributes:
13662 
   - bannerMap
13663 
  """
13664 
 
13665 
  thrift_spec = (
13666 
    None, # 0
13667 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13668 
  )
13669 
 
13670 
  def __init__(self, bannerMap=None,):
13671 
    self.bannerMap = bannerMap
13672 
 
13673 
  def read(self, iprot):
13674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13676 
      return
13677 
    iprot.readStructBegin()
13678 
    while True:
13679 
      (fname, ftype, fid) = iprot.readFieldBegin()
13680 
      if ftype == TType.STOP:
13681 
        break
13682 
      if fid == 1:
13683 
        if ftype == TType.STRUCT:
13684 
          self.bannerMap = BannerMap()
13685 
          self.bannerMap.read(iprot)
6849 kshitij.so 13686 
        else:
13687 
          iprot.skip(ftype)
13688 
      else:
13689 
        iprot.skip(ftype)
13690 
      iprot.readFieldEnd()
13691 
    iprot.readStructEnd()
13692 
 
13693 
  def write(self, oprot):
13694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13696 
      return
8579 kshitij.so 13697 
    oprot.writeStructBegin('updateBannerMap_args')
13698 
    if self.bannerMap is not None:
13699 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13700 
      self.bannerMap.write(oprot)
6849 kshitij.so 13701 
      oprot.writeFieldEnd()
13702 
    oprot.writeFieldStop()
13703 
    oprot.writeStructEnd()
13704 
 
13705 
  def validate(self):
13706 
    return
13707 
 
13708 
 
13709 
  def __repr__(self):
13710 
    L = ['%s=%r' % (key, value)
13711 
      for key, value in self.__dict__.iteritems()]
13712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13713 
 
13714 
  def __eq__(self, other):
13715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13716 
 
13717 
  def __ne__(self, other):
13718 
    return not (self == other)
13719 
 
8579 kshitij.so 13720 
class updateBannerMap_result:
6849 kshitij.so 13721 
  """
13722 
  Attributes:
13723 
   - success
13724 
  """
13725 
 
13726 
  thrift_spec = (
13727 
    (0, TType.BOOL, 'success', None, None, ), # 0
13728 
  )
13729 
 
13730 
  def __init__(self, success=None,):
13731 
    self.success = success
13732 
 
13733 
  def read(self, iprot):
13734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13736 
      return
13737 
    iprot.readStructBegin()
13738 
    while True:
13739 
      (fname, ftype, fid) = iprot.readFieldBegin()
13740 
      if ftype == TType.STOP:
13741 
        break
13742 
      if fid == 0:
13743 
        if ftype == TType.BOOL:
13744 
          self.success = iprot.readBool();
13745 
        else:
13746 
          iprot.skip(ftype)
13747 
      else:
13748 
        iprot.skip(ftype)
13749 
      iprot.readFieldEnd()
13750 
    iprot.readStructEnd()
13751 
 
13752 
  def write(self, oprot):
13753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13755 
      return
8579 kshitij.so 13756 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13757 
    if self.success is not None:
13758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13759 
      oprot.writeBool(self.success)
13760 
      oprot.writeFieldEnd()
13761 
    oprot.writeFieldStop()
13762 
    oprot.writeStructEnd()
13763 
 
13764 
  def validate(self):
13765 
    return
13766 
 
13767 
 
13768 
  def __repr__(self):
13769 
    L = ['%s=%r' % (key, value)
13770 
      for key, value in self.__dict__.iteritems()]
13771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13772 
 
13773 
  def __eq__(self, other):
13774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13775 
 
13776 
  def __ne__(self, other):
13777 
    return not (self == other)
13778 
 
13779 
class deleteBannerMap_args:
13780 
  """
13781 
  Attributes:
13782 
   - bannerName
13783 
  """
13784 
 
13785 
  thrift_spec = (
13786 
    None, # 0
13787 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13788 
  )
13789 
 
13790 
  def __init__(self, bannerName=None,):
13791 
    self.bannerName = bannerName
13792 
 
13793 
  def read(self, iprot):
13794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13796 
      return
13797 
    iprot.readStructBegin()
13798 
    while True:
13799 
      (fname, ftype, fid) = iprot.readFieldBegin()
13800 
      if ftype == TType.STOP:
13801 
        break
13802 
      if fid == 1:
13803 
        if ftype == TType.STRING:
13804 
          self.bannerName = iprot.readString();
13805 
        else:
13806 
          iprot.skip(ftype)
13807 
      else:
13808 
        iprot.skip(ftype)
13809 
      iprot.readFieldEnd()
13810 
    iprot.readStructEnd()
13811 
 
13812 
  def write(self, oprot):
13813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13815 
      return
13816 
    oprot.writeStructBegin('deleteBannerMap_args')
13817 
    if self.bannerName is not None:
13818 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13819 
      oprot.writeString(self.bannerName)
13820 
      oprot.writeFieldEnd()
13821 
    oprot.writeFieldStop()
13822 
    oprot.writeStructEnd()
13823 
 
13824 
  def validate(self):
13825 
    return
13826 
 
13827 
 
13828 
  def __repr__(self):
13829 
    L = ['%s=%r' % (key, value)
13830 
      for key, value in self.__dict__.iteritems()]
13831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13832 
 
13833 
  def __eq__(self, other):
13834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13835 
 
13836 
  def __ne__(self, other):
13837 
    return not (self == other)
13838 
 
13839 
class deleteBannerMap_result:
13840 
  """
13841 
  Attributes:
13842 
   - success
13843 
  """
13844 
 
13845 
  thrift_spec = (
13846 
    (0, TType.BOOL, 'success', None, None, ), # 0
13847 
  )
13848 
 
13849 
  def __init__(self, success=None,):
13850 
    self.success = success
13851 
 
13852 
  def read(self, iprot):
13853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13855 
      return
13856 
    iprot.readStructBegin()
13857 
    while True:
13858 
      (fname, ftype, fid) = iprot.readFieldBegin()
13859 
      if ftype == TType.STOP:
13860 
        break
13861 
      if fid == 0:
13862 
        if ftype == TType.BOOL:
13863 
          self.success = iprot.readBool();
13864 
        else:
13865 
          iprot.skip(ftype)
13866 
      else:
13867 
        iprot.skip(ftype)
13868 
      iprot.readFieldEnd()
13869 
    iprot.readStructEnd()
13870 
 
13871 
  def write(self, oprot):
13872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13874 
      return
13875 
    oprot.writeStructBegin('deleteBannerMap_result')
13876 
    if self.success is not None:
13877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13878 
      oprot.writeBool(self.success)
13879 
      oprot.writeFieldEnd()
13880 
    oprot.writeFieldStop()
13881 
    oprot.writeStructEnd()
13882 
 
13883 
  def validate(self):
13884 
    return
13885 
 
13886 
 
13887 
  def __repr__(self):
13888 
    L = ['%s=%r' % (key, value)
13889 
      for key, value in self.__dict__.iteritems()]
13890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13891 
 
13892 
  def __eq__(self, other):
13893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13894 
 
13895 
  def __ne__(self, other):
13896 
    return not (self == other)
13897 
 
13898 
class getBannerMapDetails_args:
13899 
  """
13900 
  Attributes:
13901 
   - bannerName
9155 kshitij.so 13902 
   - bannerType
6849 kshitij.so 13903 
  """
13904 
 
13905 
  thrift_spec = (
13906 
    None, # 0
13907 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13908 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13909 
  )
13910 
 
9155 kshitij.so 13911 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13912 
    self.bannerName = bannerName
9155 kshitij.so 13913 
    self.bannerType = bannerType
6849 kshitij.so 13914 
 
13915 
  def read(self, iprot):
13916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13918 
      return
13919 
    iprot.readStructBegin()
13920 
    while True:
13921 
      (fname, ftype, fid) = iprot.readFieldBegin()
13922 
      if ftype == TType.STOP:
13923 
        break
13924 
      if fid == 1:
13925 
        if ftype == TType.STRING:
13926 
          self.bannerName = iprot.readString();
13927 
        else:
13928 
          iprot.skip(ftype)
9155 kshitij.so 13929 
      elif fid == 2:
13930 
        if ftype == TType.I32:
13931 
          self.bannerType = iprot.readI32();
13932 
        else:
13933 
          iprot.skip(ftype)
6849 kshitij.so 13934 
      else:
13935 
        iprot.skip(ftype)
13936 
      iprot.readFieldEnd()
13937 
    iprot.readStructEnd()
13938 
 
13939 
  def write(self, oprot):
13940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13942 
      return
13943 
    oprot.writeStructBegin('getBannerMapDetails_args')
13944 
    if self.bannerName is not None:
13945 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13946 
      oprot.writeString(self.bannerName)
13947 
      oprot.writeFieldEnd()
9155 kshitij.so 13948 
    if self.bannerType is not None:
13949 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13950 
      oprot.writeI32(self.bannerType)
13951 
      oprot.writeFieldEnd()
6849 kshitij.so 13952 
    oprot.writeFieldStop()
13953 
    oprot.writeStructEnd()
13954 
 
13955 
  def validate(self):
13956 
    return
13957 
 
13958 
 
13959 
  def __repr__(self):
13960 
    L = ['%s=%r' % (key, value)
13961 
      for key, value in self.__dict__.iteritems()]
13962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13963 
 
13964 
  def __eq__(self, other):
13965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13966 
 
13967 
  def __ne__(self, other):
13968 
    return not (self == other)
13969 
 
13970 
class getBannerMapDetails_result:
13971 
  """
13972 
  Attributes:
13973 
   - success
13974 
  """
13975 
 
13976 
  thrift_spec = (
13977 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13978 
  )
13979 
 
13980 
  def __init__(self, success=None,):
13981 
    self.success = success
13982 
 
13983 
  def read(self, iprot):
13984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13986 
      return
13987 
    iprot.readStructBegin()
13988 
    while True:
13989 
      (fname, ftype, fid) = iprot.readFieldBegin()
13990 
      if ftype == TType.STOP:
13991 
        break
13992 
      if fid == 0:
13993 
        if ftype == TType.LIST:
13994 
          self.success = []
8590 kshitij.so 13995 
          (_etype228, _size225) = iprot.readListBegin()
13996 
          for _i229 in xrange(_size225):
13997 
            _elem230 = BannerMap()
13998 
            _elem230.read(iprot)
13999 
            self.success.append(_elem230)
6849 kshitij.so 14000 
          iprot.readListEnd()
14001 
        else:
14002 
          iprot.skip(ftype)
14003 
      else:
14004 
        iprot.skip(ftype)
14005 
      iprot.readFieldEnd()
14006 
    iprot.readStructEnd()
14007 
 
14008 
  def write(self, oprot):
14009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14011 
      return
14012 
    oprot.writeStructBegin('getBannerMapDetails_result')
14013 
    if self.success is not None:
14014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14015 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14016 
      for iter231 in self.success:
14017 
        iter231.write(oprot)
6849 kshitij.so 14018 
      oprot.writeListEnd()
14019 
      oprot.writeFieldEnd()
14020 
    oprot.writeFieldStop()
14021 
    oprot.writeStructEnd()
14022 
 
14023 
  def validate(self):
14024 
    return
14025 
 
14026 
 
14027 
  def __repr__(self):
14028 
    L = ['%s=%r' % (key, value)
14029 
      for key, value in self.__dict__.iteritems()]
14030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14031 
 
14032 
  def __eq__(self, other):
14033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14034 
 
14035 
  def __ne__(self, other):
14036 
    return not (self == other)
14037 
 
8579 kshitij.so 14038 
class addBannerUri_args:
14039 
  """
14040 
  Attributes:
14041 
   - bannerUriMappings
14042 
  """
14043 
 
14044 
  thrift_spec = (
14045 
    None, # 0
14046 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14047 
  )
14048 
 
14049 
  def __init__(self, bannerUriMappings=None,):
14050 
    self.bannerUriMappings = bannerUriMappings
14051 
 
14052 
  def read(self, iprot):
14053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14055 
      return
14056 
    iprot.readStructBegin()
14057 
    while True:
14058 
      (fname, ftype, fid) = iprot.readFieldBegin()
14059 
      if ftype == TType.STOP:
14060 
        break
14061 
      if fid == 1:
14062 
        if ftype == TType.LIST:
14063 
          self.bannerUriMappings = []
8590 kshitij.so 14064 
          (_etype235, _size232) = iprot.readListBegin()
14065 
          for _i236 in xrange(_size232):
14066 
            _elem237 = BannerUriMapping()
14067 
            _elem237.read(iprot)
14068 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14069 
          iprot.readListEnd()
14070 
        else:
14071 
          iprot.skip(ftype)
14072 
      else:
14073 
        iprot.skip(ftype)
14074 
      iprot.readFieldEnd()
14075 
    iprot.readStructEnd()
14076 
 
14077 
  def write(self, oprot):
14078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14080 
      return
14081 
    oprot.writeStructBegin('addBannerUri_args')
14082 
    if self.bannerUriMappings is not None:
14083 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14084 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14085 
      for iter238 in self.bannerUriMappings:
14086 
        iter238.write(oprot)
8579 kshitij.so 14087 
      oprot.writeListEnd()
14088 
      oprot.writeFieldEnd()
14089 
    oprot.writeFieldStop()
14090 
    oprot.writeStructEnd()
14091 
 
14092 
  def validate(self):
14093 
    return
14094 
 
14095 
 
14096 
  def __repr__(self):
14097 
    L = ['%s=%r' % (key, value)
14098 
      for key, value in self.__dict__.iteritems()]
14099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14100 
 
14101 
  def __eq__(self, other):
14102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14103 
 
14104 
  def __ne__(self, other):
14105 
    return not (self == other)
14106 
 
14107 
class addBannerUri_result:
14108 
 
14109 
  thrift_spec = (
14110 
  )
14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
14121 
      else:
14122 
        iprot.skip(ftype)
14123 
      iprot.readFieldEnd()
14124 
    iprot.readStructEnd()
14125 
 
14126 
  def write(self, oprot):
14127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14129 
      return
14130 
    oprot.writeStructBegin('addBannerUri_result')
14131 
    oprot.writeFieldStop()
14132 
    oprot.writeStructEnd()
14133 
 
14134 
  def validate(self):
14135 
    return
14136 
 
14137 
 
14138 
  def __repr__(self):
14139 
    L = ['%s=%r' % (key, value)
14140 
      for key, value in self.__dict__.iteritems()]
14141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14142 
 
14143 
  def __eq__(self, other):
14144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14145 
 
14146 
  def __ne__(self, other):
14147 
    return not (self == other)
14148 
 
14149 
class getUriMapping_args:
14150 
  """
14151 
  Attributes:
14152 
   - bannerName
9155 kshitij.so 14153 
   - bannerType
8579 kshitij.so 14154 
  """
14155 
 
14156 
  thrift_spec = (
14157 
    None, # 0
14158 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14159 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14160 
  )
14161 
 
9155 kshitij.so 14162 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14163 
    self.bannerName = bannerName
9155 kshitij.so 14164 
    self.bannerType = bannerType
8579 kshitij.so 14165 
 
14166 
  def read(self, iprot):
14167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14169 
      return
14170 
    iprot.readStructBegin()
14171 
    while True:
14172 
      (fname, ftype, fid) = iprot.readFieldBegin()
14173 
      if ftype == TType.STOP:
14174 
        break
14175 
      if fid == 1:
14176 
        if ftype == TType.STRING:
14177 
          self.bannerName = iprot.readString();
14178 
        else:
14179 
          iprot.skip(ftype)
9155 kshitij.so 14180 
      elif fid == 2:
14181 
        if ftype == TType.I32:
14182 
          self.bannerType = iprot.readI32();
14183 
        else:
14184 
          iprot.skip(ftype)
8579 kshitij.so 14185 
      else:
14186 
        iprot.skip(ftype)
14187 
      iprot.readFieldEnd()
14188 
    iprot.readStructEnd()
14189 
 
14190 
  def write(self, oprot):
14191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14193 
      return
14194 
    oprot.writeStructBegin('getUriMapping_args')
14195 
    if self.bannerName is not None:
14196 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14197 
      oprot.writeString(self.bannerName)
14198 
      oprot.writeFieldEnd()
9155 kshitij.so 14199 
    if self.bannerType is not None:
14200 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14201 
      oprot.writeI32(self.bannerType)
14202 
      oprot.writeFieldEnd()
8579 kshitij.so 14203 
    oprot.writeFieldStop()
14204 
    oprot.writeStructEnd()
14205 
 
14206 
  def validate(self):
14207 
    return
14208 
 
14209 
 
14210 
  def __repr__(self):
14211 
    L = ['%s=%r' % (key, value)
14212 
      for key, value in self.__dict__.iteritems()]
14213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14214 
 
14215 
  def __eq__(self, other):
14216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14217 
 
14218 
  def __ne__(self, other):
14219 
    return not (self == other)
14220 
 
14221 
class getUriMapping_result:
14222 
  """
14223 
  Attributes:
14224 
   - success
14225 
  """
14226 
 
14227 
  thrift_spec = (
14228 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14229 
  )
14230 
 
14231 
  def __init__(self, success=None,):
14232 
    self.success = success
14233 
 
14234 
  def read(self, iprot):
14235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14237 
      return
14238 
    iprot.readStructBegin()
14239 
    while True:
14240 
      (fname, ftype, fid) = iprot.readFieldBegin()
14241 
      if ftype == TType.STOP:
14242 
        break
14243 
      if fid == 0:
14244 
        if ftype == TType.LIST:
14245 
          self.success = []
8590 kshitij.so 14246 
          (_etype242, _size239) = iprot.readListBegin()
14247 
          for _i243 in xrange(_size239):
14248 
            _elem244 = BannerUriMapping()
14249 
            _elem244.read(iprot)
14250 
            self.success.append(_elem244)
8579 kshitij.so 14251 
          iprot.readListEnd()
14252 
        else:
14253 
          iprot.skip(ftype)
14254 
      else:
14255 
        iprot.skip(ftype)
14256 
      iprot.readFieldEnd()
14257 
    iprot.readStructEnd()
14258 
 
14259 
  def write(self, oprot):
14260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14262 
      return
14263 
    oprot.writeStructBegin('getUriMapping_result')
14264 
    if self.success is not None:
14265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14267 
      for iter245 in self.success:
14268 
        iter245.write(oprot)
8579 kshitij.so 14269 
      oprot.writeListEnd()
14270 
      oprot.writeFieldEnd()
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class addCampaign_args:
14290 
  """
14291 
  Attributes:
14292 
   - campaign
14293 
  """
14294 
 
14295 
  thrift_spec = (
14296 
    None, # 0
14297 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14298 
  )
14299 
 
14300 
  def __init__(self, campaign=None,):
14301 
    self.campaign = campaign
14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 1:
14313 
        if ftype == TType.STRUCT:
14314 
          self.campaign = Campaign()
14315 
          self.campaign.read(iprot)
14316 
        else:
14317 
          iprot.skip(ftype)
14318 
      else:
14319 
        iprot.skip(ftype)
14320 
      iprot.readFieldEnd()
14321 
    iprot.readStructEnd()
14322 
 
14323 
  def write(self, oprot):
14324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14326 
      return
14327 
    oprot.writeStructBegin('addCampaign_args')
14328 
    if self.campaign is not None:
14329 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14330 
      self.campaign.write(oprot)
14331 
      oprot.writeFieldEnd()
14332 
    oprot.writeFieldStop()
14333 
    oprot.writeStructEnd()
14334 
 
14335 
  def validate(self):
14336 
    return
14337 
 
14338 
 
14339 
  def __repr__(self):
14340 
    L = ['%s=%r' % (key, value)
14341 
      for key, value in self.__dict__.iteritems()]
14342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14343 
 
14344 
  def __eq__(self, other):
14345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14346 
 
14347 
  def __ne__(self, other):
14348 
    return not (self == other)
14349 
 
14350 
class addCampaign_result:
14351 
 
14352 
  thrift_spec = (
14353 
  )
14354 
 
14355 
  def read(self, iprot):
14356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14358 
      return
14359 
    iprot.readStructBegin()
14360 
    while True:
14361 
      (fname, ftype, fid) = iprot.readFieldBegin()
14362 
      if ftype == TType.STOP:
14363 
        break
14364 
      else:
14365 
        iprot.skip(ftype)
14366 
      iprot.readFieldEnd()
14367 
    iprot.readStructEnd()
14368 
 
14369 
  def write(self, oprot):
14370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14372 
      return
14373 
    oprot.writeStructBegin('addCampaign_result')
14374 
    oprot.writeFieldStop()
14375 
    oprot.writeStructEnd()
14376 
 
14377 
  def validate(self):
14378 
    return
14379 
 
14380 
 
14381 
  def __repr__(self):
14382 
    L = ['%s=%r' % (key, value)
14383 
      for key, value in self.__dict__.iteritems()]
14384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14385 
 
14386 
  def __eq__(self, other):
14387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14388 
 
14389 
  def __ne__(self, other):
14390 
    return not (self == other)
14391 
 
14392 
class getCampaigns_args:
14393 
  """
14394 
  Attributes:
14395 
   - campaignName
14396 
  """
14397 
 
14398 
  thrift_spec = (
14399 
    None, # 0
14400 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14401 
  )
14402 
 
14403 
  def __init__(self, campaignName=None,):
14404 
    self.campaignName = campaignName
14405 
 
14406 
  def read(self, iprot):
14407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14409 
      return
14410 
    iprot.readStructBegin()
14411 
    while True:
14412 
      (fname, ftype, fid) = iprot.readFieldBegin()
14413 
      if ftype == TType.STOP:
14414 
        break
14415 
      if fid == 1:
14416 
        if ftype == TType.STRING:
14417 
          self.campaignName = iprot.readString();
14418 
        else:
14419 
          iprot.skip(ftype)
14420 
      else:
14421 
        iprot.skip(ftype)
14422 
      iprot.readFieldEnd()
14423 
    iprot.readStructEnd()
14424 
 
14425 
  def write(self, oprot):
14426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14428 
      return
14429 
    oprot.writeStructBegin('getCampaigns_args')
14430 
    if self.campaignName is not None:
14431 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14432 
      oprot.writeString(self.campaignName)
14433 
      oprot.writeFieldEnd()
14434 
    oprot.writeFieldStop()
14435 
    oprot.writeStructEnd()
14436 
 
14437 
  def validate(self):
14438 
    return
14439 
 
14440 
 
14441 
  def __repr__(self):
14442 
    L = ['%s=%r' % (key, value)
14443 
      for key, value in self.__dict__.iteritems()]
14444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14445 
 
14446 
  def __eq__(self, other):
14447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14448 
 
14449 
  def __ne__(self, other):
14450 
    return not (self == other)
14451 
 
14452 
class getCampaigns_result:
14453 
  """
14454 
  Attributes:
14455 
   - success
14456 
  """
14457 
 
14458 
  thrift_spec = (
14459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14460 
  )
14461 
 
14462 
  def __init__(self, success=None,):
14463 
    self.success = success
14464 
 
14465 
  def read(self, iprot):
14466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14468 
      return
14469 
    iprot.readStructBegin()
14470 
    while True:
14471 
      (fname, ftype, fid) = iprot.readFieldBegin()
14472 
      if ftype == TType.STOP:
14473 
        break
14474 
      if fid == 0:
14475 
        if ftype == TType.LIST:
14476 
          self.success = []
8590 kshitij.so 14477 
          (_etype249, _size246) = iprot.readListBegin()
14478 
          for _i250 in xrange(_size246):
14479 
            _elem251 = Campaign()
14480 
            _elem251.read(iprot)
14481 
            self.success.append(_elem251)
8579 kshitij.so 14482 
          iprot.readListEnd()
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
14494 
    oprot.writeStructBegin('getCampaigns_result')
14495 
    if self.success is not None:
14496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14498 
      for iter252 in self.success:
14499 
        iter252.write(oprot)
8579 kshitij.so 14500 
      oprot.writeListEnd()
14501 
      oprot.writeFieldEnd()
14502 
    oprot.writeFieldStop()
14503 
    oprot.writeStructEnd()
14504 
 
14505 
  def validate(self):
14506 
    return
14507 
 
14508 
 
14509 
  def __repr__(self):
14510 
    L = ['%s=%r' % (key, value)
14511 
      for key, value in self.__dict__.iteritems()]
14512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14513 
 
14514 
  def __eq__(self, other):
14515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14516 
 
14517 
  def __ne__(self, other):
14518 
    return not (self == other)
14519 
 
14520 
class deleteCampaign_args:
14521 
  """
14522 
  Attributes:
14523 
   - campaignId
14524 
  """
14525 
 
14526 
  thrift_spec = (
14527 
    None, # 0
14528 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14529 
  )
14530 
 
14531 
  def __init__(self, campaignId=None,):
14532 
    self.campaignId = campaignId
14533 
 
14534 
  def read(self, iprot):
14535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14537 
      return
14538 
    iprot.readStructBegin()
14539 
    while True:
14540 
      (fname, ftype, fid) = iprot.readFieldBegin()
14541 
      if ftype == TType.STOP:
14542 
        break
14543 
      if fid == 1:
14544 
        if ftype == TType.I64:
14545 
          self.campaignId = iprot.readI64();
14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      else:
14549 
        iprot.skip(ftype)
14550 
      iprot.readFieldEnd()
14551 
    iprot.readStructEnd()
14552 
 
14553 
  def write(self, oprot):
14554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14556 
      return
14557 
    oprot.writeStructBegin('deleteCampaign_args')
14558 
    if self.campaignId is not None:
14559 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14560 
      oprot.writeI64(self.campaignId)
14561 
      oprot.writeFieldEnd()
14562 
    oprot.writeFieldStop()
14563 
    oprot.writeStructEnd()
14564 
 
14565 
  def validate(self):
14566 
    return
14567 
 
14568 
 
14569 
  def __repr__(self):
14570 
    L = ['%s=%r' % (key, value)
14571 
      for key, value in self.__dict__.iteritems()]
14572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14573 
 
14574 
  def __eq__(self, other):
14575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14576 
 
14577 
  def __ne__(self, other):
14578 
    return not (self == other)
14579 
 
14580 
class deleteCampaign_result:
14581 
 
14582 
  thrift_spec = (
14583 
  )
14584 
 
14585 
  def read(self, iprot):
14586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14588 
      return
14589 
    iprot.readStructBegin()
14590 
    while True:
14591 
      (fname, ftype, fid) = iprot.readFieldBegin()
14592 
      if ftype == TType.STOP:
14593 
        break
14594 
      else:
14595 
        iprot.skip(ftype)
14596 
      iprot.readFieldEnd()
14597 
    iprot.readStructEnd()
14598 
 
14599 
  def write(self, oprot):
14600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14602 
      return
14603 
    oprot.writeStructBegin('deleteCampaign_result')
14604 
    oprot.writeFieldStop()
14605 
    oprot.writeStructEnd()
14606 
 
14607 
  def validate(self):
14608 
    return
14609 
 
14610 
 
14611 
  def __repr__(self):
14612 
    L = ['%s=%r' % (key, value)
14613 
      for key, value in self.__dict__.iteritems()]
14614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14615 
 
14616 
  def __eq__(self, other):
14617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14618 
 
14619 
  def __ne__(self, other):
14620 
    return not (self == other)
14621 
 
14622 
class getAllCampaigns_args:
14623 
 
14624 
  thrift_spec = (
14625 
  )
14626 
 
14627 
  def read(self, iprot):
14628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14630 
      return
14631 
    iprot.readStructBegin()
14632 
    while True:
14633 
      (fname, ftype, fid) = iprot.readFieldBegin()
14634 
      if ftype == TType.STOP:
14635 
        break
14636 
      else:
14637 
        iprot.skip(ftype)
14638 
      iprot.readFieldEnd()
14639 
    iprot.readStructEnd()
14640 
 
14641 
  def write(self, oprot):
14642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14644 
      return
14645 
    oprot.writeStructBegin('getAllCampaigns_args')
14646 
    oprot.writeFieldStop()
14647 
    oprot.writeStructEnd()
14648 
 
14649 
  def validate(self):
14650 
    return
14651 
 
14652 
 
14653 
  def __repr__(self):
14654 
    L = ['%s=%r' % (key, value)
14655 
      for key, value in self.__dict__.iteritems()]
14656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14657 
 
14658 
  def __eq__(self, other):
14659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14660 
 
14661 
  def __ne__(self, other):
14662 
    return not (self == other)
14663 
 
14664 
class getAllCampaigns_result:
14665 
  """
14666 
  Attributes:
14667 
   - success
14668 
  """
14669 
 
14670 
  thrift_spec = (
14671 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14672 
  )
14673 
 
14674 
  def __init__(self, success=None,):
14675 
    self.success = success
14676 
 
14677 
  def read(self, iprot):
14678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14680 
      return
14681 
    iprot.readStructBegin()
14682 
    while True:
14683 
      (fname, ftype, fid) = iprot.readFieldBegin()
14684 
      if ftype == TType.STOP:
14685 
        break
14686 
      if fid == 0:
14687 
        if ftype == TType.LIST:
14688 
          self.success = []
8590 kshitij.so 14689 
          (_etype256, _size253) = iprot.readListBegin()
14690 
          for _i257 in xrange(_size253):
14691 
            _elem258 = iprot.readString();
14692 
            self.success.append(_elem258)
8579 kshitij.so 14693 
          iprot.readListEnd()
14694 
        else:
14695 
          iprot.skip(ftype)
14696 
      else:
14697 
        iprot.skip(ftype)
14698 
      iprot.readFieldEnd()
14699 
    iprot.readStructEnd()
14700 
 
14701 
  def write(self, oprot):
14702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14704 
      return
14705 
    oprot.writeStructBegin('getAllCampaigns_result')
14706 
    if self.success is not None:
14707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14708 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14709 
      for iter259 in self.success:
14710 
        oprot.writeString(iter259)
8579 kshitij.so 14711 
      oprot.writeListEnd()
14712 
      oprot.writeFieldEnd()
14713 
    oprot.writeFieldStop()
14714 
    oprot.writeStructEnd()
14715 
 
14716 
  def validate(self):
14717 
    return
14718 
 
14719 
 
14720 
  def __repr__(self):
14721 
    L = ['%s=%r' % (key, value)
14722 
      for key, value in self.__dict__.iteritems()]
14723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14724 
 
14725 
  def __eq__(self, other):
14726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14727 
 
14728 
  def __ne__(self, other):
14729 
    return not (self == other)
14730 
 
9155 kshitij.so 14731 
class getActiveBannersForMobileSite_args:
14732 
 
14733 
  thrift_spec = (
14734 
  )
14735 
 
14736 
  def read(self, iprot):
14737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14739 
      return
14740 
    iprot.readStructBegin()
14741 
    while True:
14742 
      (fname, ftype, fid) = iprot.readFieldBegin()
14743 
      if ftype == TType.STOP:
14744 
        break
14745 
      else:
14746 
        iprot.skip(ftype)
14747 
      iprot.readFieldEnd()
14748 
    iprot.readStructEnd()
14749 
 
14750 
  def write(self, oprot):
14751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14753 
      return
14754 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14755 
    oprot.writeFieldStop()
14756 
    oprot.writeStructEnd()
14757 
 
14758 
  def validate(self):
14759 
    return
14760 
 
14761 
 
14762 
  def __repr__(self):
14763 
    L = ['%s=%r' % (key, value)
14764 
      for key, value in self.__dict__.iteritems()]
14765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14766 
 
14767 
  def __eq__(self, other):
14768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14769 
 
14770 
  def __ne__(self, other):
14771 
    return not (self == other)
14772 
 
14773 
class getActiveBannersForMobileSite_result:
14774 
  """
14775 
  Attributes:
14776 
   - success
14777 
  """
14778 
 
14779 
  thrift_spec = (
14780 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14781 
  )
14782 
 
14783 
  def __init__(self, success=None,):
14784 
    self.success = success
14785 
 
14786 
  def read(self, iprot):
14787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14789 
      return
14790 
    iprot.readStructBegin()
14791 
    while True:
14792 
      (fname, ftype, fid) = iprot.readFieldBegin()
14793 
      if ftype == TType.STOP:
14794 
        break
14795 
      if fid == 0:
14796 
        if ftype == TType.MAP:
14797 
          self.success = {}
14798 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14799 
          for _i264 in xrange(_size260):
14800 
            _key265 = iprot.readString();
14801 
            _val266 = []
14802 
            (_etype270, _size267) = iprot.readListBegin()
14803 
            for _i271 in xrange(_size267):
14804 
              _elem272 = Banner()
14805 
              _elem272.read(iprot)
14806 
              _val266.append(_elem272)
14807 
            iprot.readListEnd()
14808 
            self.success[_key265] = _val266
14809 
          iprot.readMapEnd()
14810 
        else:
14811 
          iprot.skip(ftype)
14812 
      else:
14813 
        iprot.skip(ftype)
14814 
      iprot.readFieldEnd()
14815 
    iprot.readStructEnd()
14816 
 
14817 
  def write(self, oprot):
14818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14820 
      return
14821 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14822 
    if self.success is not None:
14823 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14824 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14825 
      for kiter273,viter274 in self.success.items():
14826 
        oprot.writeString(kiter273)
14827 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14828 
        for iter275 in viter274:
14829 
          iter275.write(oprot)
14830 
        oprot.writeListEnd()
14831 
      oprot.writeMapEnd()
14832 
      oprot.writeFieldEnd()
14833 
    oprot.writeFieldStop()
14834 
    oprot.writeStructEnd()
14835 
 
14836 
  def validate(self):
14837 
    return
14838 
 
14839 
 
14840 
  def __repr__(self):
14841 
    L = ['%s=%r' % (key, value)
14842 
      for key, value in self.__dict__.iteritems()]
14843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14844 
 
14845 
  def __eq__(self, other):
14846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14847 
 
14848 
  def __ne__(self, other):
14849 
    return not (self == other)
14850 
 
5944 mandeep.dh 14851 
class deleteSimilarItem_args:
14852 
  """
14853 
  Attributes:
14854 
   - itemId
14855 
   - catalogItemId
14856 
  """
14857 
 
14858 
  thrift_spec = (
14859 
    None, # 0
14860 
    (1, TType.I64, 'itemId', None, None, ), # 1
14861 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14862 
  )
14863 
 
14864 
  def __init__(self, itemId=None, catalogItemId=None,):
14865 
    self.itemId = itemId
14866 
    self.catalogItemId = catalogItemId
14867 
 
14868 
  def read(self, iprot):
14869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14871 
      return
14872 
    iprot.readStructBegin()
14873 
    while True:
14874 
      (fname, ftype, fid) = iprot.readFieldBegin()
14875 
      if ftype == TType.STOP:
14876 
        break
14877 
      if fid == 1:
14878 
        if ftype == TType.I64:
14879 
          self.itemId = iprot.readI64();
14880 
        else:
14881 
          iprot.skip(ftype)
14882 
      elif fid == 2:
14883 
        if ftype == TType.I64:
14884 
          self.catalogItemId = iprot.readI64();
14885 
        else:
14886 
          iprot.skip(ftype)
14887 
      else:
14888 
        iprot.skip(ftype)
14889 
      iprot.readFieldEnd()
14890 
    iprot.readStructEnd()
14891 
 
14892 
  def write(self, oprot):
14893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14895 
      return
14896 
    oprot.writeStructBegin('deleteSimilarItem_args')
14897 
    if self.itemId is not None:
14898 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14899 
      oprot.writeI64(self.itemId)
14900 
      oprot.writeFieldEnd()
14901 
    if self.catalogItemId is not None:
14902 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14903 
      oprot.writeI64(self.catalogItemId)
14904 
      oprot.writeFieldEnd()
14905 
    oprot.writeFieldStop()
14906 
    oprot.writeStructEnd()
14907 
 
14908 
  def validate(self):
14909 
    return
14910 
 
14911 
 
14912 
  def __repr__(self):
14913 
    L = ['%s=%r' % (key, value)
14914 
      for key, value in self.__dict__.iteritems()]
14915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14916 
 
14917 
  def __eq__(self, other):
14918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14919 
 
14920 
  def __ne__(self, other):
14921 
    return not (self == other)
14922 
 
14923 
class deleteSimilarItem_result:
14924 
  """
14925 
  Attributes:
14926 
   - success
14927 
   - cex
14928 
  """
14929 
 
14930 
  thrift_spec = (
14931 
    (0, TType.BOOL, 'success', None, None, ), # 0
14932 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14933 
  )
14934 
 
14935 
  def __init__(self, success=None, cex=None,):
14936 
    self.success = success
14937 
    self.cex = cex
14938 
 
14939 
  def read(self, iprot):
14940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14942 
      return
14943 
    iprot.readStructBegin()
14944 
    while True:
14945 
      (fname, ftype, fid) = iprot.readFieldBegin()
14946 
      if ftype == TType.STOP:
14947 
        break
14948 
      if fid == 0:
14949 
        if ftype == TType.BOOL:
14950 
          self.success = iprot.readBool();
14951 
        else:
14952 
          iprot.skip(ftype)
14953 
      elif fid == 1:
14954 
        if ftype == TType.STRUCT:
14955 
          self.cex = CatalogServiceException()
14956 
          self.cex.read(iprot)
14957 
        else:
14958 
          iprot.skip(ftype)
14959 
      else:
14960 
        iprot.skip(ftype)
14961 
      iprot.readFieldEnd()
14962 
    iprot.readStructEnd()
14963 
 
14964 
  def write(self, oprot):
14965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14967 
      return
14968 
    oprot.writeStructBegin('deleteSimilarItem_result')
14969 
    if self.success is not None:
14970 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14971 
      oprot.writeBool(self.success)
14972 
      oprot.writeFieldEnd()
14973 
    if self.cex is not None:
14974 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14975 
      self.cex.write(oprot)
14976 
      oprot.writeFieldEnd()
14977 
    oprot.writeFieldStop()
14978 
    oprot.writeStructEnd()
14979 
 
14980 
  def validate(self):
14981 
    return
14982 
 
14983 
 
14984 
  def __repr__(self):
14985 
    L = ['%s=%r' % (key, value)
14986 
      for key, value in self.__dict__.iteritems()]
14987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14988 
 
14989 
  def __eq__(self, other):
14990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14991 
 
14992 
  def __ne__(self, other):
14993 
    return not (self == other)
14994 
 
14995 
class checkSimilarItem_args:
14996 
  """
14997 
  Attributes:
14998 
   - brand
14999 
   - modelNumber
15000 
   - modelName
15001 
   - color
15002 
  """
15003 
 
15004 
  thrift_spec = (
15005 
    None, # 0
15006 
    (1, TType.STRING, 'brand', None, None, ), # 1
15007 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15008 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15009 
    (4, TType.STRING, 'color', None, None, ), # 4
15010 
  )
15011 
 
15012 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15013 
    self.brand = brand
15014 
    self.modelNumber = modelNumber
15015 
    self.modelName = modelName
15016 
    self.color = color
15017 
 
15018 
  def read(self, iprot):
15019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15021 
      return
15022 
    iprot.readStructBegin()
15023 
    while True:
15024 
      (fname, ftype, fid) = iprot.readFieldBegin()
15025 
      if ftype == TType.STOP:
15026 
        break
15027 
      if fid == 1:
15028 
        if ftype == TType.STRING:
15029 
          self.brand = iprot.readString();
15030 
        else:
15031 
          iprot.skip(ftype)
15032 
      elif fid == 2:
15033 
        if ftype == TType.STRING:
15034 
          self.modelNumber = iprot.readString();
15035 
        else:
15036 
          iprot.skip(ftype)
15037 
      elif fid == 3:
15038 
        if ftype == TType.STRING:
15039 
          self.modelName = iprot.readString();
15040 
        else:
15041 
          iprot.skip(ftype)
15042 
      elif fid == 4:
15043 
        if ftype == TType.STRING:
15044 
          self.color = iprot.readString();
15045 
        else:
15046 
          iprot.skip(ftype)
15047 
      else:
15048 
        iprot.skip(ftype)
15049 
      iprot.readFieldEnd()
15050 
    iprot.readStructEnd()
15051 
 
15052 
  def write(self, oprot):
15053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15055 
      return
15056 
    oprot.writeStructBegin('checkSimilarItem_args')
15057 
    if self.brand is not None:
15058 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15059 
      oprot.writeString(self.brand)
15060 
      oprot.writeFieldEnd()
15061 
    if self.modelNumber is not None:
15062 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15063 
      oprot.writeString(self.modelNumber)
15064 
      oprot.writeFieldEnd()
15065 
    if self.modelName is not None:
15066 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15067 
      oprot.writeString(self.modelName)
15068 
      oprot.writeFieldEnd()
15069 
    if self.color is not None:
15070 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15071 
      oprot.writeString(self.color)
15072 
      oprot.writeFieldEnd()
15073 
    oprot.writeFieldStop()
15074 
    oprot.writeStructEnd()
15075 
 
15076 
  def validate(self):
15077 
    return
15078 
 
15079 
 
15080 
  def __repr__(self):
15081 
    L = ['%s=%r' % (key, value)
15082 
      for key, value in self.__dict__.iteritems()]
15083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15084 
 
15085 
  def __eq__(self, other):
15086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15087 
 
15088 
  def __ne__(self, other):
15089 
    return not (self == other)
15090 
 
15091 
class checkSimilarItem_result:
15092 
  """
15093 
  Attributes:
15094 
   - success
15095 
  """
15096 
 
15097 
  thrift_spec = (
15098 
    (0, TType.I64, 'success', None, None, ), # 0
15099 
  )
15100 
 
15101 
  def __init__(self, success=None,):
15102 
    self.success = success
15103 
 
15104 
  def read(self, iprot):
15105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15107 
      return
15108 
    iprot.readStructBegin()
15109 
    while True:
15110 
      (fname, ftype, fid) = iprot.readFieldBegin()
15111 
      if ftype == TType.STOP:
15112 
        break
15113 
      if fid == 0:
15114 
        if ftype == TType.I64:
15115 
          self.success = iprot.readI64();
15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      else:
15119 
        iprot.skip(ftype)
15120 
      iprot.readFieldEnd()
15121 
    iprot.readStructEnd()
15122 
 
15123 
  def write(self, oprot):
15124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15126 
      return
15127 
    oprot.writeStructBegin('checkSimilarItem_result')
15128 
    if self.success is not None:
15129 
      oprot.writeFieldBegin('success', TType.I64, 0)
15130 
      oprot.writeI64(self.success)
15131 
      oprot.writeFieldEnd()
15132 
    oprot.writeFieldStop()
15133 
    oprot.writeStructEnd()
15134 
 
15135 
  def validate(self):
15136 
    return
15137 
 
15138 
 
15139 
  def __repr__(self):
15140 
    L = ['%s=%r' % (key, value)
15141 
      for key, value in self.__dict__.iteritems()]
15142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15143 
 
15144 
  def __eq__(self, other):
15145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15146 
 
15147 
  def __ne__(self, other):
15148 
    return not (self == other)
15149 
 
15150 
class validateRiskyStatus_args:
15151 
  """
15152 
  Attributes:
15153 
   - itemId
15154 
  """
15155 
 
15156 
  thrift_spec = (
15157 
    None, # 0
15158 
    (1, TType.I64, 'itemId', None, None, ), # 1
15159 
  )
15160 
 
15161 
  def __init__(self, itemId=None,):
15162 
    self.itemId = itemId
15163 
 
15164 
  def read(self, iprot):
15165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15167 
      return
15168 
    iprot.readStructBegin()
15169 
    while True:
15170 
      (fname, ftype, fid) = iprot.readFieldBegin()
15171 
      if ftype == TType.STOP:
15172 
        break
15173 
      if fid == 1:
15174 
        if ftype == TType.I64:
15175 
          self.itemId = iprot.readI64();
15176 
        else:
15177 
          iprot.skip(ftype)
15178 
      else:
15179 
        iprot.skip(ftype)
15180 
      iprot.readFieldEnd()
15181 
    iprot.readStructEnd()
15182 
 
15183 
  def write(self, oprot):
15184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15186 
      return
15187 
    oprot.writeStructBegin('validateRiskyStatus_args')
15188 
    if self.itemId is not None:
15189 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15190 
      oprot.writeI64(self.itemId)
15191 
      oprot.writeFieldEnd()
15192 
    oprot.writeFieldStop()
15193 
    oprot.writeStructEnd()
15194 
 
15195 
  def validate(self):
15196 
    return
15197 
 
15198 
 
15199 
  def __repr__(self):
15200 
    L = ['%s=%r' % (key, value)
15201 
      for key, value in self.__dict__.iteritems()]
15202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15203 
 
15204 
  def __eq__(self, other):
15205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15206 
 
15207 
  def __ne__(self, other):
15208 
    return not (self == other)
15209 
 
15210 
class validateRiskyStatus_result:
15211 
 
15212 
  thrift_spec = (
15213 
  )
15214 
 
15215 
  def read(self, iprot):
15216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15218 
      return
15219 
    iprot.readStructBegin()
15220 
    while True:
15221 
      (fname, ftype, fid) = iprot.readFieldBegin()
15222 
      if ftype == TType.STOP:
15223 
        break
15224 
      else:
15225 
        iprot.skip(ftype)
15226 
      iprot.readFieldEnd()
15227 
    iprot.readStructEnd()
15228 
 
15229 
  def write(self, oprot):
15230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15232 
      return
15233 
    oprot.writeStructBegin('validateRiskyStatus_result')
15234 
    oprot.writeFieldStop()
15235 
    oprot.writeStructEnd()
15236 
 
15237 
  def validate(self):
15238 
    return
15239 
 
15240 
 
15241 
  def __repr__(self):
15242 
    L = ['%s=%r' % (key, value)
15243 
      for key, value in self.__dict__.iteritems()]
15244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15245 
 
15246 
  def __eq__(self, other):
15247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15248 
 
15249 
  def __ne__(self, other):
15250 
    return not (self == other)
15251 
 
15252 
class changeItemRiskyFlag_args:
15253 
  """
15254 
  Attributes:
15255 
   - itemId
15256 
   - risky
15257 
  """
15258 
 
15259 
  thrift_spec = (
15260 
    None, # 0
15261 
    (1, TType.I64, 'itemId', None, None, ), # 1
15262 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15263 
  )
15264 
 
15265 
  def __init__(self, itemId=None, risky=None,):
15266 
    self.itemId = itemId
15267 
    self.risky = risky
15268 
 
15269 
  def read(self, iprot):
15270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15272 
      return
15273 
    iprot.readStructBegin()
15274 
    while True:
15275 
      (fname, ftype, fid) = iprot.readFieldBegin()
15276 
      if ftype == TType.STOP:
15277 
        break
15278 
      if fid == 1:
15279 
        if ftype == TType.I64:
15280 
          self.itemId = iprot.readI64();
15281 
        else:
15282 
          iprot.skip(ftype)
15283 
      elif fid == 2:
15284 
        if ftype == TType.BOOL:
15285 
          self.risky = iprot.readBool();
15286 
        else:
15287 
          iprot.skip(ftype)
15288 
      else:
15289 
        iprot.skip(ftype)
15290 
      iprot.readFieldEnd()
15291 
    iprot.readStructEnd()
15292 
 
15293 
  def write(self, oprot):
15294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15296 
      return
15297 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15298 
    if self.itemId is not None:
15299 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15300 
      oprot.writeI64(self.itemId)
15301 
      oprot.writeFieldEnd()
15302 
    if self.risky is not None:
15303 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15304 
      oprot.writeBool(self.risky)
15305 
      oprot.writeFieldEnd()
15306 
    oprot.writeFieldStop()
15307 
    oprot.writeStructEnd()
15308 
 
15309 
  def validate(self):
15310 
    return
15311 
 
15312 
 
15313 
  def __repr__(self):
15314 
    L = ['%s=%r' % (key, value)
15315 
      for key, value in self.__dict__.iteritems()]
15316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15317 
 
15318 
  def __eq__(self, other):
15319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15320 
 
15321 
  def __ne__(self, other):
15322 
    return not (self == other)
15323 
 
15324 
class changeItemRiskyFlag_result:
15325 
 
15326 
  thrift_spec = (
15327 
  )
15328 
 
15329 
  def read(self, iprot):
15330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15332 
      return
15333 
    iprot.readStructBegin()
15334 
    while True:
15335 
      (fname, ftype, fid) = iprot.readFieldBegin()
15336 
      if ftype == TType.STOP:
15337 
        break
15338 
      else:
15339 
        iprot.skip(ftype)
15340 
      iprot.readFieldEnd()
15341 
    iprot.readStructEnd()
15342 
 
15343 
  def write(self, oprot):
15344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15346 
      return
15347 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15348 
    oprot.writeFieldStop()
15349 
    oprot.writeStructEnd()
15350 
 
15351 
  def validate(self):
15352 
    return
15353 
 
15354 
 
15355 
  def __repr__(self):
15356 
    L = ['%s=%r' % (key, value)
15357 
      for key, value in self.__dict__.iteritems()]
15358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15359 
 
15360 
  def __eq__(self, other):
15361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15362 
 
15363 
  def __ne__(self, other):
15364 
    return not (self == other)
15365 
 
15366 
class getItemsByRiskyFlag_args:
15367 
 
15368 
  thrift_spec = (
15369 
  )
15370 
 
15371 
  def read(self, iprot):
15372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15374 
      return
15375 
    iprot.readStructBegin()
15376 
    while True:
15377 
      (fname, ftype, fid) = iprot.readFieldBegin()
15378 
      if ftype == TType.STOP:
15379 
        break
15380 
      else:
15381 
        iprot.skip(ftype)
15382 
      iprot.readFieldEnd()
15383 
    iprot.readStructEnd()
15384 
 
15385 
  def write(self, oprot):
15386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15388 
      return
15389 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15390 
    oprot.writeFieldStop()
15391 
    oprot.writeStructEnd()
15392 
 
15393 
  def validate(self):
15394 
    return
15395 
 
15396 
 
15397 
  def __repr__(self):
15398 
    L = ['%s=%r' % (key, value)
15399 
      for key, value in self.__dict__.iteritems()]
15400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15401 
 
15402 
  def __eq__(self, other):
15403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15404 
 
15405 
  def __ne__(self, other):
15406 
    return not (self == other)
15407 
 
15408 
class getItemsByRiskyFlag_result:
15409 
  """
15410 
  Attributes:
15411 
   - success
15412 
  """
15413 
 
15414 
  thrift_spec = (
15415 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15416 
  )
15417 
 
15418 
  def __init__(self, success=None,):
15419 
    self.success = success
15420 
 
15421 
  def read(self, iprot):
15422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15424 
      return
15425 
    iprot.readStructBegin()
15426 
    while True:
15427 
      (fname, ftype, fid) = iprot.readFieldBegin()
15428 
      if ftype == TType.STOP:
15429 
        break
15430 
      if fid == 0:
15431 
        if ftype == TType.LIST:
15432 
          self.success = []
9155 kshitij.so 15433 
          (_etype279, _size276) = iprot.readListBegin()
15434 
          for _i280 in xrange(_size276):
15435 
            _elem281 = Item()
15436 
            _elem281.read(iprot)
15437 
            self.success.append(_elem281)
5944 mandeep.dh 15438 
          iprot.readListEnd()
15439 
        else:
15440 
          iprot.skip(ftype)
15441 
      else:
15442 
        iprot.skip(ftype)
15443 
      iprot.readFieldEnd()
15444 
    iprot.readStructEnd()
15445 
 
15446 
  def write(self, oprot):
15447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15449 
      return
15450 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15451 
    if self.success is not None:
15452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15453 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15454 
      for iter282 in self.success:
15455 
        iter282.write(oprot)
5944 mandeep.dh 15456 
      oprot.writeListEnd()
15457 
      oprot.writeFieldEnd()
15458 
    oprot.writeFieldStop()
15459 
    oprot.writeStructEnd()
15460 
 
15461 
  def validate(self):
15462 
    return
15463 
 
15464 
 
15465 
  def __repr__(self):
15466 
    L = ['%s=%r' % (key, value)
15467 
      for key, value in self.__dict__.iteritems()]
15468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15469 
 
15470 
  def __eq__(self, other):
15471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15472 
 
15473 
  def __ne__(self, other):
15474 
    return not (self == other)
15475 
 
15476 
class getItemsForMasterSheet_args:
15477 
  """
15478 
  Attributes:
15479 
   - category
15480 
   - brand
15481 
  """
15482 
 
15483 
  thrift_spec = (
15484 
    None, # 0
15485 
    (1, TType.STRING, 'category', None, None, ), # 1
15486 
    (2, TType.STRING, 'brand', None, None, ), # 2
15487 
  )
15488 
 
15489 
  def __init__(self, category=None, brand=None,):
15490 
    self.category = category
15491 
    self.brand = brand
15492 
 
15493 
  def read(self, iprot):
15494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15496 
      return
15497 
    iprot.readStructBegin()
15498 
    while True:
15499 
      (fname, ftype, fid) = iprot.readFieldBegin()
15500 
      if ftype == TType.STOP:
15501 
        break
15502 
      if fid == 1:
15503 
        if ftype == TType.STRING:
15504 
          self.category = iprot.readString();
15505 
        else:
15506 
          iprot.skip(ftype)
15507 
      elif fid == 2:
15508 
        if ftype == TType.STRING:
15509 
          self.brand = iprot.readString();
15510 
        else:
15511 
          iprot.skip(ftype)
15512 
      else:
15513 
        iprot.skip(ftype)
15514 
      iprot.readFieldEnd()
15515 
    iprot.readStructEnd()
15516 
 
15517 
  def write(self, oprot):
15518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15520 
      return
15521 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15522 
    if self.category is not None:
15523 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15524 
      oprot.writeString(self.category)
15525 
      oprot.writeFieldEnd()
15526 
    if self.brand is not None:
15527 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15528 
      oprot.writeString(self.brand)
15529 
      oprot.writeFieldEnd()
15530 
    oprot.writeFieldStop()
15531 
    oprot.writeStructEnd()
15532 
 
15533 
  def validate(self):
15534 
    return
15535 
 
15536 
 
15537 
  def __repr__(self):
15538 
    L = ['%s=%r' % (key, value)
15539 
      for key, value in self.__dict__.iteritems()]
15540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15541 
 
15542 
  def __eq__(self, other):
15543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15544 
 
15545 
  def __ne__(self, other):
15546 
    return not (self == other)
15547 
 
15548 
class getItemsForMasterSheet_result:
15549 
  """
15550 
  Attributes:
15551 
   - success
15552 
  """
15553 
 
15554 
  thrift_spec = (
15555 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15556 
  )
15557 
 
15558 
  def __init__(self, success=None,):
15559 
    self.success = success
15560 
 
15561 
  def read(self, iprot):
15562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15564 
      return
15565 
    iprot.readStructBegin()
15566 
    while True:
15567 
      (fname, ftype, fid) = iprot.readFieldBegin()
15568 
      if ftype == TType.STOP:
15569 
        break
15570 
      if fid == 0:
15571 
        if ftype == TType.LIST:
15572 
          self.success = []
9155 kshitij.so 15573 
          (_etype286, _size283) = iprot.readListBegin()
15574 
          for _i287 in xrange(_size283):
15575 
            _elem288 = Item()
15576 
            _elem288.read(iprot)
15577 
            self.success.append(_elem288)
5944 mandeep.dh 15578 
          iprot.readListEnd()
15579 
        else:
15580 
          iprot.skip(ftype)
15581 
      else:
15582 
        iprot.skip(ftype)
15583 
      iprot.readFieldEnd()
15584 
    iprot.readStructEnd()
15585 
 
15586 
  def write(self, oprot):
15587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15589 
      return
15590 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15591 
    if self.success is not None:
15592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15594 
      for iter289 in self.success:
15595 
        iter289.write(oprot)
5944 mandeep.dh 15596 
      oprot.writeListEnd()
15597 
      oprot.writeFieldEnd()
15598 
    oprot.writeFieldStop()
15599 
    oprot.writeStructEnd()
15600 
 
15601 
  def validate(self):
15602 
    return
15603 
 
15604 
 
15605 
  def __repr__(self):
15606 
    L = ['%s=%r' % (key, value)
15607 
      for key, value in self.__dict__.iteritems()]
15608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15609 
 
15610 
  def __eq__(self, other):
15611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15612 
 
15613 
  def __ne__(self, other):
15614 
    return not (self == other)
15615 
 
15616 
class getSimilarItemsCatalogIds_args:
15617 
  """
15618 
  Attributes:
15619 
   - beginIndex
15620 
   - totalItems
15621 
   - itemId
15622 
  """
15623 
 
15624 
  thrift_spec = (
15625 
    None, # 0
15626 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15627 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15628 
    (3, TType.I64, 'itemId', None, None, ), # 3
15629 
  )
15630 
 
15631 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15632 
    self.beginIndex = beginIndex
15633 
    self.totalItems = totalItems
15634 
    self.itemId = itemId
15635 
 
15636 
  def read(self, iprot):
15637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15639 
      return
15640 
    iprot.readStructBegin()
15641 
    while True:
15642 
      (fname, ftype, fid) = iprot.readFieldBegin()
15643 
      if ftype == TType.STOP:
15644 
        break
15645 
      if fid == 1:
15646 
        if ftype == TType.I64:
15647 
          self.beginIndex = iprot.readI64();
15648 
        else:
15649 
          iprot.skip(ftype)
15650 
      elif fid == 2:
15651 
        if ftype == TType.I64:
15652 
          self.totalItems = iprot.readI64();
15653 
        else:
15654 
          iprot.skip(ftype)
15655 
      elif fid == 3:
15656 
        if ftype == TType.I64:
15657 
          self.itemId = iprot.readI64();
15658 
        else:
15659 
          iprot.skip(ftype)
15660 
      else:
15661 
        iprot.skip(ftype)
15662 
      iprot.readFieldEnd()
15663 
    iprot.readStructEnd()
15664 
 
15665 
  def write(self, oprot):
15666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15668 
      return
15669 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15670 
    if self.beginIndex is not None:
15671 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15672 
      oprot.writeI64(self.beginIndex)
15673 
      oprot.writeFieldEnd()
15674 
    if self.totalItems is not None:
15675 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15676 
      oprot.writeI64(self.totalItems)
15677 
      oprot.writeFieldEnd()
15678 
    if self.itemId is not None:
15679 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15680 
      oprot.writeI64(self.itemId)
15681 
      oprot.writeFieldEnd()
15682 
    oprot.writeFieldStop()
15683 
    oprot.writeStructEnd()
15684 
 
15685 
  def validate(self):
15686 
    return
15687 
 
15688 
 
15689 
  def __repr__(self):
15690 
    L = ['%s=%r' % (key, value)
15691 
      for key, value in self.__dict__.iteritems()]
15692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15693 
 
15694 
  def __eq__(self, other):
15695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15696 
 
15697 
  def __ne__(self, other):
15698 
    return not (self == other)
15699 
 
15700 
class getSimilarItemsCatalogIds_result:
15701 
  """
15702 
  Attributes:
15703 
   - success
15704 
  """
15705 
 
15706 
  thrift_spec = (
15707 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15708 
  )
15709 
 
15710 
  def __init__(self, success=None,):
15711 
    self.success = success
15712 
 
15713 
  def read(self, iprot):
15714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15716 
      return
15717 
    iprot.readStructBegin()
15718 
    while True:
15719 
      (fname, ftype, fid) = iprot.readFieldBegin()
15720 
      if ftype == TType.STOP:
15721 
        break
15722 
      if fid == 0:
15723 
        if ftype == TType.LIST:
15724 
          self.success = []
9155 kshitij.so 15725 
          (_etype293, _size290) = iprot.readListBegin()
15726 
          for _i294 in xrange(_size290):
15727 
            _elem295 = iprot.readI64();
15728 
            self.success.append(_elem295)
5944 mandeep.dh 15729 
          iprot.readListEnd()
15730 
        else:
15731 
          iprot.skip(ftype)
15732 
      else:
15733 
        iprot.skip(ftype)
15734 
      iprot.readFieldEnd()
15735 
    iprot.readStructEnd()
15736 
 
15737 
  def write(self, oprot):
15738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15740 
      return
15741 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15742 
    if self.success is not None:
15743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15744 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15745 
      for iter296 in self.success:
15746 
        oprot.writeI64(iter296)
5944 mandeep.dh 15747 
      oprot.writeListEnd()
15748 
      oprot.writeFieldEnd()
15749 
    oprot.writeFieldStop()
15750 
    oprot.writeStructEnd()
15751 
 
15752 
  def validate(self):
15753 
    return
15754 
 
15755 
 
15756 
  def __repr__(self):
15757 
    L = ['%s=%r' % (key, value)
15758 
      for key, value in self.__dict__.iteritems()]
15759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15760 
 
15761 
  def __eq__(self, other):
15762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15763 
 
15764 
  def __ne__(self, other):
15765 
    return not (self == other)
15766 
 
15767 
class addProductNotification_args:
15768 
  """
15769 
  Attributes:
15770 
   - itemId
15771 
   - email
15772 
  """
15773 
 
15774 
  thrift_spec = None
15775 
  def __init__(self, itemId=None, email=None,):
15776 
    self.itemId = itemId
15777 
    self.email = email
15778 
 
15779 
  def read(self, iprot):
15780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15782 
      return
15783 
    iprot.readStructBegin()
15784 
    while True:
15785 
      (fname, ftype, fid) = iprot.readFieldBegin()
15786 
      if ftype == TType.STOP:
15787 
        break
15788 
      if fid == -1:
15789 
        if ftype == TType.I64:
15790 
          self.itemId = iprot.readI64();
15791 
        else:
15792 
          iprot.skip(ftype)
15793 
      elif fid == -2:
15794 
        if ftype == TType.STRING:
15795 
          self.email = iprot.readString();
15796 
        else:
15797 
          iprot.skip(ftype)
15798 
      else:
15799 
        iprot.skip(ftype)
15800 
      iprot.readFieldEnd()
15801 
    iprot.readStructEnd()
15802 
 
15803 
  def write(self, oprot):
15804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15806 
      return
15807 
    oprot.writeStructBegin('addProductNotification_args')
15808 
    if self.email is not None:
15809 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15810 
      oprot.writeString(self.email)
15811 
      oprot.writeFieldEnd()
15812 
    if self.itemId is not None:
15813 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15814 
      oprot.writeI64(self.itemId)
15815 
      oprot.writeFieldEnd()
15816 
    oprot.writeFieldStop()
15817 
    oprot.writeStructEnd()
15818 
 
15819 
  def validate(self):
15820 
    return
15821 
 
15822 
 
15823 
  def __repr__(self):
15824 
    L = ['%s=%r' % (key, value)
15825 
      for key, value in self.__dict__.iteritems()]
15826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15827 
 
15828 
  def __eq__(self, other):
15829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15830 
 
15831 
  def __ne__(self, other):
15832 
    return not (self == other)
15833 
 
15834 
class addProductNotification_result:
15835 
  """
15836 
  Attributes:
15837 
   - success
15838 
  """
15839 
 
15840 
  thrift_spec = (
15841 
    (0, TType.BOOL, 'success', None, None, ), # 0
15842 
  )
15843 
 
15844 
  def __init__(self, success=None,):
15845 
    self.success = success
15846 
 
15847 
  def read(self, iprot):
15848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15850 
      return
15851 
    iprot.readStructBegin()
15852 
    while True:
15853 
      (fname, ftype, fid) = iprot.readFieldBegin()
15854 
      if ftype == TType.STOP:
15855 
        break
15856 
      if fid == 0:
15857 
        if ftype == TType.BOOL:
15858 
          self.success = iprot.readBool();
15859 
        else:
15860 
          iprot.skip(ftype)
15861 
      else:
15862 
        iprot.skip(ftype)
15863 
      iprot.readFieldEnd()
15864 
    iprot.readStructEnd()
15865 
 
15866 
  def write(self, oprot):
15867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15869 
      return
15870 
    oprot.writeStructBegin('addProductNotification_result')
15871 
    if self.success is not None:
15872 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15873 
      oprot.writeBool(self.success)
15874 
      oprot.writeFieldEnd()
15875 
    oprot.writeFieldStop()
15876 
    oprot.writeStructEnd()
15877 
 
15878 
  def validate(self):
15879 
    return
15880 
 
15881 
 
15882 
  def __repr__(self):
15883 
    L = ['%s=%r' % (key, value)
15884 
      for key, value in self.__dict__.iteritems()]
15885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15886 
 
15887 
  def __eq__(self, other):
15888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15889 
 
15890 
  def __ne__(self, other):
15891 
    return not (self == other)
15892 
 
15893 
class sendProductNotifications_args:
15894 
 
15895 
  thrift_spec = (
15896 
  )
15897 
 
15898 
  def read(self, iprot):
15899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15901 
      return
15902 
    iprot.readStructBegin()
15903 
    while True:
15904 
      (fname, ftype, fid) = iprot.readFieldBegin()
15905 
      if ftype == TType.STOP:
15906 
        break
15907 
      else:
15908 
        iprot.skip(ftype)
15909 
      iprot.readFieldEnd()
15910 
    iprot.readStructEnd()
15911 
 
15912 
  def write(self, oprot):
15913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15915 
      return
15916 
    oprot.writeStructBegin('sendProductNotifications_args')
15917 
    oprot.writeFieldStop()
15918 
    oprot.writeStructEnd()
15919 
 
15920 
  def validate(self):
15921 
    return
15922 
 
15923 
 
15924 
  def __repr__(self):
15925 
    L = ['%s=%r' % (key, value)
15926 
      for key, value in self.__dict__.iteritems()]
15927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15928 
 
15929 
  def __eq__(self, other):
15930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15931 
 
15932 
  def __ne__(self, other):
15933 
    return not (self == other)
15934 
 
15935 
class sendProductNotifications_result:
15936 
  """
15937 
  Attributes:
15938 
   - success
15939 
  """
15940 
 
15941 
  thrift_spec = (
15942 
    (0, TType.BOOL, 'success', None, None, ), # 0
15943 
  )
15944 
 
15945 
  def __init__(self, success=None,):
15946 
    self.success = success
15947 
 
15948 
  def read(self, iprot):
15949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15951 
      return
15952 
    iprot.readStructBegin()
15953 
    while True:
15954 
      (fname, ftype, fid) = iprot.readFieldBegin()
15955 
      if ftype == TType.STOP:
15956 
        break
15957 
      if fid == 0:
15958 
        if ftype == TType.BOOL:
15959 
          self.success = iprot.readBool();
15960 
        else:
15961 
          iprot.skip(ftype)
15962 
      else:
15963 
        iprot.skip(ftype)
15964 
      iprot.readFieldEnd()
15965 
    iprot.readStructEnd()
15966 
 
15967 
  def write(self, oprot):
15968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15970 
      return
15971 
    oprot.writeStructBegin('sendProductNotifications_result')
15972 
    if self.success is not None:
15973 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15974 
      oprot.writeBool(self.success)
15975 
      oprot.writeFieldEnd()
15976 
    oprot.writeFieldStop()
15977 
    oprot.writeStructEnd()
15978 
 
15979 
  def validate(self):
15980 
    return
15981 
 
15982 
 
15983 
  def __repr__(self):
15984 
    L = ['%s=%r' % (key, value)
15985 
      for key, value in self.__dict__.iteritems()]
15986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15987 
 
15988 
  def __eq__(self, other):
15989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15990 
 
15991 
  def __ne__(self, other):
15992 
    return not (self == other)
15993 
 
15994 
class getAllBrandsByCategory_args:
15995 
  """
15996 
  Attributes:
15997 
   - categoryId
15998 
  """
15999 
 
16000 
  thrift_spec = (
16001 
    None, # 0
16002 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16003 
  )
16004 
 
16005 
  def __init__(self, categoryId=None,):
16006 
    self.categoryId = categoryId
16007 
 
16008 
  def read(self, iprot):
16009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16011 
      return
16012 
    iprot.readStructBegin()
16013 
    while True:
16014 
      (fname, ftype, fid) = iprot.readFieldBegin()
16015 
      if ftype == TType.STOP:
16016 
        break
16017 
      if fid == 1:
16018 
        if ftype == TType.I64:
16019 
          self.categoryId = iprot.readI64();
16020 
        else:
16021 
          iprot.skip(ftype)
16022 
      else:
16023 
        iprot.skip(ftype)
16024 
      iprot.readFieldEnd()
16025 
    iprot.readStructEnd()
16026 
 
16027 
  def write(self, oprot):
16028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16030 
      return
16031 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16032 
    if self.categoryId is not None:
16033 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16034 
      oprot.writeI64(self.categoryId)
16035 
      oprot.writeFieldEnd()
16036 
    oprot.writeFieldStop()
16037 
    oprot.writeStructEnd()
16038 
 
16039 
  def validate(self):
16040 
    return
16041 
 
16042 
 
16043 
  def __repr__(self):
16044 
    L = ['%s=%r' % (key, value)
16045 
      for key, value in self.__dict__.iteritems()]
16046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16047 
 
16048 
  def __eq__(self, other):
16049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16050 
 
16051 
  def __ne__(self, other):
16052 
    return not (self == other)
16053 
 
16054 
class getAllBrandsByCategory_result:
16055 
  """
16056 
  Attributes:
16057 
   - success
16058 
  """
16059 
 
16060 
  thrift_spec = (
16061 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16062 
  )
16063 
 
16064 
  def __init__(self, success=None,):
16065 
    self.success = success
16066 
 
16067 
  def read(self, iprot):
16068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16070 
      return
16071 
    iprot.readStructBegin()
16072 
    while True:
16073 
      (fname, ftype, fid) = iprot.readFieldBegin()
16074 
      if ftype == TType.STOP:
16075 
        break
16076 
      if fid == 0:
16077 
        if ftype == TType.LIST:
16078 
          self.success = []
9155 kshitij.so 16079 
          (_etype300, _size297) = iprot.readListBegin()
16080 
          for _i301 in xrange(_size297):
16081 
            _elem302 = iprot.readString();
16082 
            self.success.append(_elem302)
5944 mandeep.dh 16083 
          iprot.readListEnd()
16084 
        else:
16085 
          iprot.skip(ftype)
16086 
      else:
16087 
        iprot.skip(ftype)
16088 
      iprot.readFieldEnd()
16089 
    iprot.readStructEnd()
16090 
 
16091 
  def write(self, oprot):
16092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16094 
      return
16095 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16096 
    if self.success is not None:
16097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16098 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16099 
      for iter303 in self.success:
16100 
        oprot.writeString(iter303)
5944 mandeep.dh 16101 
      oprot.writeListEnd()
16102 
      oprot.writeFieldEnd()
16103 
    oprot.writeFieldStop()
16104 
    oprot.writeStructEnd()
16105 
 
16106 
  def validate(self):
16107 
    return
16108 
 
16109 
 
16110 
  def __repr__(self):
16111 
    L = ['%s=%r' % (key, value)
16112 
      for key, value in self.__dict__.iteritems()]
16113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16114 
 
16115 
  def __eq__(self, other):
16116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16117 
 
16118 
  def __ne__(self, other):
16119 
    return not (self == other)
16120 
 
16121 
class getAllBrands_args:
16122 
 
16123 
  thrift_spec = (
16124 
  )
16125 
 
16126 
  def read(self, iprot):
16127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16129 
      return
16130 
    iprot.readStructBegin()
16131 
    while True:
16132 
      (fname, ftype, fid) = iprot.readFieldBegin()
16133 
      if ftype == TType.STOP:
16134 
        break
16135 
      else:
16136 
        iprot.skip(ftype)
16137 
      iprot.readFieldEnd()
16138 
    iprot.readStructEnd()
16139 
 
16140 
  def write(self, oprot):
16141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16143 
      return
16144 
    oprot.writeStructBegin('getAllBrands_args')
16145 
    oprot.writeFieldStop()
16146 
    oprot.writeStructEnd()
16147 
 
16148 
  def validate(self):
16149 
    return
16150 
 
16151 
 
16152 
  def __repr__(self):
16153 
    L = ['%s=%r' % (key, value)
16154 
      for key, value in self.__dict__.iteritems()]
16155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16156 
 
16157 
  def __eq__(self, other):
16158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16159 
 
16160 
  def __ne__(self, other):
16161 
    return not (self == other)
16162 
 
16163 
class getAllBrands_result:
16164 
  """
16165 
  Attributes:
16166 
   - success
16167 
  """
16168 
 
16169 
  thrift_spec = (
16170 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16171 
  )
16172 
 
16173 
  def __init__(self, success=None,):
16174 
    self.success = success
16175 
 
16176 
  def read(self, iprot):
16177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16179 
      return
16180 
    iprot.readStructBegin()
16181 
    while True:
16182 
      (fname, ftype, fid) = iprot.readFieldBegin()
16183 
      if ftype == TType.STOP:
16184 
        break
16185 
      if fid == 0:
16186 
        if ftype == TType.LIST:
16187 
          self.success = []
9155 kshitij.so 16188 
          (_etype307, _size304) = iprot.readListBegin()
16189 
          for _i308 in xrange(_size304):
16190 
            _elem309 = iprot.readString();
16191 
            self.success.append(_elem309)
5944 mandeep.dh 16192 
          iprot.readListEnd()
16193 
        else:
16194 
          iprot.skip(ftype)
16195 
      else:
16196 
        iprot.skip(ftype)
16197 
      iprot.readFieldEnd()
16198 
    iprot.readStructEnd()
16199 
 
16200 
  def write(self, oprot):
16201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16203 
      return
16204 
    oprot.writeStructBegin('getAllBrands_result')
16205 
    if self.success is not None:
16206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16207 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16208 
      for iter310 in self.success:
16209 
        oprot.writeString(iter310)
5944 mandeep.dh 16210 
      oprot.writeListEnd()
16211 
      oprot.writeFieldEnd()
16212 
    oprot.writeFieldStop()
16213 
    oprot.writeStructEnd()
16214 
 
16215 
  def validate(self):
16216 
    return
16217 
 
16218 
 
16219 
  def __repr__(self):
16220 
    L = ['%s=%r' % (key, value)
16221 
      for key, value in self.__dict__.iteritems()]
16222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16223 
 
16224 
  def __eq__(self, other):
16225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16226 
 
16227 
  def __ne__(self, other):
16228 
    return not (self == other)
16229 
 
16230 
class getAllSources_args:
16231 
 
16232 
  thrift_spec = (
16233 
  )
16234 
 
16235 
  def read(self, iprot):
16236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16238 
      return
16239 
    iprot.readStructBegin()
16240 
    while True:
16241 
      (fname, ftype, fid) = iprot.readFieldBegin()
16242 
      if ftype == TType.STOP:
16243 
        break
16244 
      else:
16245 
        iprot.skip(ftype)
16246 
      iprot.readFieldEnd()
16247 
    iprot.readStructEnd()
16248 
 
16249 
  def write(self, oprot):
16250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16252 
      return
16253 
    oprot.writeStructBegin('getAllSources_args')
16254 
    oprot.writeFieldStop()
16255 
    oprot.writeStructEnd()
16256 
 
16257 
  def validate(self):
16258 
    return
16259 
 
16260 
 
16261 
  def __repr__(self):
16262 
    L = ['%s=%r' % (key, value)
16263 
      for key, value in self.__dict__.iteritems()]
16264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16265 
 
16266 
  def __eq__(self, other):
16267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16268 
 
16269 
  def __ne__(self, other):
16270 
    return not (self == other)
16271 
 
16272 
class getAllSources_result:
16273 
  """
16274 
  Attributes:
16275 
   - success
16276 
  """
16277 
 
16278 
  thrift_spec = (
16279 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16280 
  )
16281 
 
16282 
  def __init__(self, success=None,):
16283 
    self.success = success
16284 
 
16285 
  def read(self, iprot):
16286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16288 
      return
16289 
    iprot.readStructBegin()
16290 
    while True:
16291 
      (fname, ftype, fid) = iprot.readFieldBegin()
16292 
      if ftype == TType.STOP:
16293 
        break
16294 
      if fid == 0:
16295 
        if ftype == TType.LIST:
16296 
          self.success = []
9155 kshitij.so 16297 
          (_etype314, _size311) = iprot.readListBegin()
16298 
          for _i315 in xrange(_size311):
16299 
            _elem316 = Source()
16300 
            _elem316.read(iprot)
16301 
            self.success.append(_elem316)
5944 mandeep.dh 16302 
          iprot.readListEnd()
16303 
        else:
16304 
          iprot.skip(ftype)
16305 
      else:
16306 
        iprot.skip(ftype)
16307 
      iprot.readFieldEnd()
16308 
    iprot.readStructEnd()
16309 
 
16310 
  def write(self, oprot):
16311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16313 
      return
16314 
    oprot.writeStructBegin('getAllSources_result')
16315 
    if self.success is not None:
16316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16318 
      for iter317 in self.success:
16319 
        iter317.write(oprot)
5944 mandeep.dh 16320 
      oprot.writeListEnd()
16321 
      oprot.writeFieldEnd()
16322 
    oprot.writeFieldStop()
16323 
    oprot.writeStructEnd()
16324 
 
16325 
  def validate(self):
16326 
    return
16327 
 
16328 
 
16329 
  def __repr__(self):
16330 
    L = ['%s=%r' % (key, value)
16331 
      for key, value in self.__dict__.iteritems()]
16332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16333 
 
16334 
  def __eq__(self, other):
16335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16336 
 
16337 
  def __ne__(self, other):
16338 
    return not (self == other)
16339 
 
16340 
class getItemPricingBySource_args:
16341 
  """
16342 
  Attributes:
16343 
   - itemId
16344 
   - sourceId
16345 
  """
16346 
 
16347 
  thrift_spec = (
16348 
    None, # 0
16349 
    (1, TType.I64, 'itemId', None, None, ), # 1
16350 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16351 
  )
16352 
 
16353 
  def __init__(self, itemId=None, sourceId=None,):
16354 
    self.itemId = itemId
16355 
    self.sourceId = sourceId
16356 
 
16357 
  def read(self, iprot):
16358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16360 
      return
16361 
    iprot.readStructBegin()
16362 
    while True:
16363 
      (fname, ftype, fid) = iprot.readFieldBegin()
16364 
      if ftype == TType.STOP:
16365 
        break
16366 
      if fid == 1:
16367 
        if ftype == TType.I64:
16368 
          self.itemId = iprot.readI64();
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      elif fid == 2:
16372 
        if ftype == TType.I64:
16373 
          self.sourceId = iprot.readI64();
16374 
        else:
16375 
          iprot.skip(ftype)
16376 
      else:
16377 
        iprot.skip(ftype)
16378 
      iprot.readFieldEnd()
16379 
    iprot.readStructEnd()
16380 
 
16381 
  def write(self, oprot):
16382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16384 
      return
16385 
    oprot.writeStructBegin('getItemPricingBySource_args')
16386 
    if self.itemId is not None:
16387 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16388 
      oprot.writeI64(self.itemId)
16389 
      oprot.writeFieldEnd()
16390 
    if self.sourceId is not None:
16391 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16392 
      oprot.writeI64(self.sourceId)
16393 
      oprot.writeFieldEnd()
16394 
    oprot.writeFieldStop()
16395 
    oprot.writeStructEnd()
16396 
 
16397 
  def validate(self):
16398 
    return
16399 
 
16400 
 
16401 
  def __repr__(self):
16402 
    L = ['%s=%r' % (key, value)
16403 
      for key, value in self.__dict__.iteritems()]
16404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16405 
 
16406 
  def __eq__(self, other):
16407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16408 
 
16409 
  def __ne__(self, other):
16410 
    return not (self == other)
16411 
 
16412 
class getItemPricingBySource_result:
16413 
  """
16414 
  Attributes:
16415 
   - success
16416 
   - cex
16417 
  """
16418 
 
16419 
  thrift_spec = (
16420 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16421 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16422 
  )
16423 
 
16424 
  def __init__(self, success=None, cex=None,):
16425 
    self.success = success
16426 
    self.cex = cex
16427 
 
16428 
  def read(self, iprot):
16429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16431 
      return
16432 
    iprot.readStructBegin()
16433 
    while True:
16434 
      (fname, ftype, fid) = iprot.readFieldBegin()
16435 
      if ftype == TType.STOP:
16436 
        break
16437 
      if fid == 0:
16438 
        if ftype == TType.STRUCT:
16439 
          self.success = SourceItemPricing()
16440 
          self.success.read(iprot)
16441 
        else:
16442 
          iprot.skip(ftype)
16443 
      elif fid == 1:
16444 
        if ftype == TType.STRUCT:
16445 
          self.cex = CatalogServiceException()
16446 
          self.cex.read(iprot)
16447 
        else:
16448 
          iprot.skip(ftype)
16449 
      else:
16450 
        iprot.skip(ftype)
16451 
      iprot.readFieldEnd()
16452 
    iprot.readStructEnd()
16453 
 
16454 
  def write(self, oprot):
16455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16457 
      return
16458 
    oprot.writeStructBegin('getItemPricingBySource_result')
16459 
    if self.success is not None:
16460 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16461 
      self.success.write(oprot)
16462 
      oprot.writeFieldEnd()
16463 
    if self.cex is not None:
16464 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16465 
      self.cex.write(oprot)
16466 
      oprot.writeFieldEnd()
16467 
    oprot.writeFieldStop()
16468 
    oprot.writeStructEnd()
16469 
 
16470 
  def validate(self):
16471 
    return
16472 
 
16473 
 
16474 
  def __repr__(self):
16475 
    L = ['%s=%r' % (key, value)
16476 
      for key, value in self.__dict__.iteritems()]
16477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16478 
 
16479 
  def __eq__(self, other):
16480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16481 
 
16482 
  def __ne__(self, other):
16483 
    return not (self == other)
16484 
 
16485 
class addSourceItemPricing_args:
16486 
  """
16487 
  Attributes:
16488 
   - sourceItemPricing
16489 
  """
16490 
 
16491 
  thrift_spec = (
16492 
    None, # 0
16493 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16494 
  )
16495 
 
16496 
  def __init__(self, sourceItemPricing=None,):
16497 
    self.sourceItemPricing = sourceItemPricing
16498 
 
16499 
  def read(self, iprot):
16500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16502 
      return
16503 
    iprot.readStructBegin()
16504 
    while True:
16505 
      (fname, ftype, fid) = iprot.readFieldBegin()
16506 
      if ftype == TType.STOP:
16507 
        break
16508 
      if fid == 1:
16509 
        if ftype == TType.STRUCT:
16510 
          self.sourceItemPricing = SourceItemPricing()
16511 
          self.sourceItemPricing.read(iprot)
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      else:
16515 
        iprot.skip(ftype)
16516 
      iprot.readFieldEnd()
16517 
    iprot.readStructEnd()
16518 
 
16519 
  def write(self, oprot):
16520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16522 
      return
16523 
    oprot.writeStructBegin('addSourceItemPricing_args')
16524 
    if self.sourceItemPricing is not None:
16525 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16526 
      self.sourceItemPricing.write(oprot)
16527 
      oprot.writeFieldEnd()
16528 
    oprot.writeFieldStop()
16529 
    oprot.writeStructEnd()
16530 
 
16531 
  def validate(self):
16532 
    return
16533 
 
16534 
 
16535 
  def __repr__(self):
16536 
    L = ['%s=%r' % (key, value)
16537 
      for key, value in self.__dict__.iteritems()]
16538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16539 
 
16540 
  def __eq__(self, other):
16541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16542 
 
16543 
  def __ne__(self, other):
16544 
    return not (self == other)
16545 
 
16546 
class addSourceItemPricing_result:
16547 
  """
16548 
  Attributes:
16549 
   - cex
16550 
  """
16551 
 
16552 
  thrift_spec = (
16553 
    None, # 0
16554 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16555 
  )
16556 
 
16557 
  def __init__(self, cex=None,):
16558 
    self.cex = cex
16559 
 
16560 
  def read(self, iprot):
16561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16563 
      return
16564 
    iprot.readStructBegin()
16565 
    while True:
16566 
      (fname, ftype, fid) = iprot.readFieldBegin()
16567 
      if ftype == TType.STOP:
16568 
        break
16569 
      if fid == 1:
16570 
        if ftype == TType.STRUCT:
16571 
          self.cex = CatalogServiceException()
16572 
          self.cex.read(iprot)
16573 
        else:
16574 
          iprot.skip(ftype)
16575 
      else:
16576 
        iprot.skip(ftype)
16577 
      iprot.readFieldEnd()
16578 
    iprot.readStructEnd()
16579 
 
16580 
  def write(self, oprot):
16581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16583 
      return
16584 
    oprot.writeStructBegin('addSourceItemPricing_result')
16585 
    if self.cex is not None:
16586 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16587 
      self.cex.write(oprot)
16588 
      oprot.writeFieldEnd()
16589 
    oprot.writeFieldStop()
16590 
    oprot.writeStructEnd()
16591 
 
16592 
  def validate(self):
16593 
    return
16594 
 
16595 
 
16596 
  def __repr__(self):
16597 
    L = ['%s=%r' % (key, value)
16598 
      for key, value in self.__dict__.iteritems()]
16599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16600 
 
16601 
  def __eq__(self, other):
16602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16603 
 
16604 
  def __ne__(self, other):
16605 
    return not (self == other)
16606 
 
16607 
class getAllSourcePricing_args:
16608 
  """
16609 
  Attributes:
16610 
   - itemId
16611 
  """
16612 
 
16613 
  thrift_spec = (
16614 
    None, # 0
16615 
    (1, TType.I64, 'itemId', None, None, ), # 1
16616 
  )
16617 
 
16618 
  def __init__(self, itemId=None,):
16619 
    self.itemId = itemId
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == 1:
16631 
        if ftype == TType.I64:
16632 
          self.itemId = iprot.readI64();
16633 
        else:
16634 
          iprot.skip(ftype)
16635 
      else:
16636 
        iprot.skip(ftype)
16637 
      iprot.readFieldEnd()
16638 
    iprot.readStructEnd()
16639 
 
16640 
  def write(self, oprot):
16641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16643 
      return
16644 
    oprot.writeStructBegin('getAllSourcePricing_args')
16645 
    if self.itemId is not None:
16646 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16647 
      oprot.writeI64(self.itemId)
16648 
      oprot.writeFieldEnd()
16649 
    oprot.writeFieldStop()
16650 
    oprot.writeStructEnd()
16651 
 
16652 
  def validate(self):
16653 
    return
16654 
 
16655 
 
16656 
  def __repr__(self):
16657 
    L = ['%s=%r' % (key, value)
16658 
      for key, value in self.__dict__.iteritems()]
16659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16660 
 
16661 
  def __eq__(self, other):
16662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16663 
 
16664 
  def __ne__(self, other):
16665 
    return not (self == other)
16666 
 
16667 
class getAllSourcePricing_result:
16668 
  """
16669 
  Attributes:
16670 
   - success
16671 
   - cex
16672 
  """
16673 
 
16674 
  thrift_spec = (
16675 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16676 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16677 
  )
16678 
 
16679 
  def __init__(self, success=None, cex=None,):
16680 
    self.success = success
16681 
    self.cex = cex
16682 
 
16683 
  def read(self, iprot):
16684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16686 
      return
16687 
    iprot.readStructBegin()
16688 
    while True:
16689 
      (fname, ftype, fid) = iprot.readFieldBegin()
16690 
      if ftype == TType.STOP:
16691 
        break
16692 
      if fid == 0:
16693 
        if ftype == TType.LIST:
16694 
          self.success = []
9155 kshitij.so 16695 
          (_etype321, _size318) = iprot.readListBegin()
16696 
          for _i322 in xrange(_size318):
16697 
            _elem323 = SourceItemPricing()
16698 
            _elem323.read(iprot)
16699 
            self.success.append(_elem323)
5944 mandeep.dh 16700 
          iprot.readListEnd()
16701 
        else:
16702 
          iprot.skip(ftype)
16703 
      elif fid == 1:
16704 
        if ftype == TType.STRUCT:
16705 
          self.cex = CatalogServiceException()
16706 
          self.cex.read(iprot)
16707 
        else:
16708 
          iprot.skip(ftype)
16709 
      else:
16710 
        iprot.skip(ftype)
16711 
      iprot.readFieldEnd()
16712 
    iprot.readStructEnd()
16713 
 
16714 
  def write(self, oprot):
16715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16717 
      return
16718 
    oprot.writeStructBegin('getAllSourcePricing_result')
16719 
    if self.success is not None:
16720 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16721 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16722 
      for iter324 in self.success:
16723 
        iter324.write(oprot)
5944 mandeep.dh 16724 
      oprot.writeListEnd()
16725 
      oprot.writeFieldEnd()
16726 
    if self.cex is not None:
16727 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16728 
      self.cex.write(oprot)
16729 
      oprot.writeFieldEnd()
16730 
    oprot.writeFieldStop()
16731 
    oprot.writeStructEnd()
16732 
 
16733 
  def validate(self):
16734 
    return
16735 
 
16736 
 
16737 
  def __repr__(self):
16738 
    L = ['%s=%r' % (key, value)
16739 
      for key, value in self.__dict__.iteritems()]
16740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16741 
 
16742 
  def __eq__(self, other):
16743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16744 
 
16745 
  def __ne__(self, other):
16746 
    return not (self == other)
16747 
 
16748 
class getItemForSource_args:
16749 
  """
16750 
  Attributes:
16751 
   - item_id
16752 
   - sourceId
16753 
  """
16754 
 
16755 
  thrift_spec = (
16756 
    None, # 0
16757 
    (1, TType.I64, 'item_id', None, None, ), # 1
16758 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16759 
  )
16760 
 
16761 
  def __init__(self, item_id=None, sourceId=None,):
16762 
    self.item_id = item_id
16763 
    self.sourceId = sourceId
16764 
 
16765 
  def read(self, iprot):
16766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16768 
      return
16769 
    iprot.readStructBegin()
16770 
    while True:
16771 
      (fname, ftype, fid) = iprot.readFieldBegin()
16772 
      if ftype == TType.STOP:
16773 
        break
16774 
      if fid == 1:
16775 
        if ftype == TType.I64:
16776 
          self.item_id = iprot.readI64();
16777 
        else:
16778 
          iprot.skip(ftype)
16779 
      elif fid == 2:
16780 
        if ftype == TType.I64:
16781 
          self.sourceId = iprot.readI64();
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      else:
16785 
        iprot.skip(ftype)
16786 
      iprot.readFieldEnd()
16787 
    iprot.readStructEnd()
16788 
 
16789 
  def write(self, oprot):
16790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16792 
      return
16793 
    oprot.writeStructBegin('getItemForSource_args')
16794 
    if self.item_id is not None:
16795 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16796 
      oprot.writeI64(self.item_id)
16797 
      oprot.writeFieldEnd()
16798 
    if self.sourceId is not None:
16799 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16800 
      oprot.writeI64(self.sourceId)
16801 
      oprot.writeFieldEnd()
16802 
    oprot.writeFieldStop()
16803 
    oprot.writeStructEnd()
16804 
 
16805 
  def validate(self):
16806 
    return
16807 
 
16808 
 
16809 
  def __repr__(self):
16810 
    L = ['%s=%r' % (key, value)
16811 
      for key, value in self.__dict__.iteritems()]
16812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16813 
 
16814 
  def __eq__(self, other):
16815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16816 
 
16817 
  def __ne__(self, other):
16818 
    return not (self == other)
16819 
 
16820 
class getItemForSource_result:
16821 
  """
16822 
  Attributes:
16823 
   - success
16824 
   - cex
16825 
  """
16826 
 
16827 
  thrift_spec = (
16828 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16829 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16830 
  )
16831 
 
16832 
  def __init__(self, success=None, cex=None,):
16833 
    self.success = success
16834 
    self.cex = cex
16835 
 
16836 
  def read(self, iprot):
16837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16839 
      return
16840 
    iprot.readStructBegin()
16841 
    while True:
16842 
      (fname, ftype, fid) = iprot.readFieldBegin()
16843 
      if ftype == TType.STOP:
16844 
        break
16845 
      if fid == 0:
16846 
        if ftype == TType.STRUCT:
16847 
          self.success = Item()
16848 
          self.success.read(iprot)
16849 
        else:
16850 
          iprot.skip(ftype)
16851 
      elif fid == 1:
16852 
        if ftype == TType.STRUCT:
16853 
          self.cex = CatalogServiceException()
16854 
          self.cex.read(iprot)
16855 
        else:
16856 
          iprot.skip(ftype)
16857 
      else:
16858 
        iprot.skip(ftype)
16859 
      iprot.readFieldEnd()
16860 
    iprot.readStructEnd()
16861 
 
16862 
  def write(self, oprot):
16863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16865 
      return
16866 
    oprot.writeStructBegin('getItemForSource_result')
16867 
    if self.success is not None:
16868 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16869 
      self.success.write(oprot)
16870 
      oprot.writeFieldEnd()
16871 
    if self.cex is not None:
16872 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16873 
      self.cex.write(oprot)
16874 
      oprot.writeFieldEnd()
16875 
    oprot.writeFieldStop()
16876 
    oprot.writeStructEnd()
16877 
 
16878 
  def validate(self):
16879 
    return
16880 
 
16881 
 
16882 
  def __repr__(self):
16883 
    L = ['%s=%r' % (key, value)
16884 
      for key, value in self.__dict__.iteritems()]
16885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16886 
 
16887 
  def __eq__(self, other):
16888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16889 
 
16890 
  def __ne__(self, other):
16891 
    return not (self == other)
16892 
 
16893 
class searchItemsInRange_args:
16894 
  """
16895 
  Attributes:
16896 
   - searchTerms
16897 
   - offset
16898 
   - limit
16899 
  """
16900 
 
16901 
  thrift_spec = (
16902 
    None, # 0
16903 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16904 
    (2, TType.I64, 'offset', None, None, ), # 2
16905 
    (3, TType.I64, 'limit', None, None, ), # 3
16906 
  )
16907 
 
16908 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16909 
    self.searchTerms = searchTerms
16910 
    self.offset = offset
16911 
    self.limit = limit
16912 
 
16913 
  def read(self, iprot):
16914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16916 
      return
16917 
    iprot.readStructBegin()
16918 
    while True:
16919 
      (fname, ftype, fid) = iprot.readFieldBegin()
16920 
      if ftype == TType.STOP:
16921 
        break
16922 
      if fid == 1:
16923 
        if ftype == TType.LIST:
16924 
          self.searchTerms = []
9155 kshitij.so 16925 
          (_etype328, _size325) = iprot.readListBegin()
16926 
          for _i329 in xrange(_size325):
16927 
            _elem330 = iprot.readString();
16928 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16929 
          iprot.readListEnd()
16930 
        else:
16931 
          iprot.skip(ftype)
16932 
      elif fid == 2:
16933 
        if ftype == TType.I64:
16934 
          self.offset = iprot.readI64();
16935 
        else:
16936 
          iprot.skip(ftype)
16937 
      elif fid == 3:
16938 
        if ftype == TType.I64:
16939 
          self.limit = iprot.readI64();
16940 
        else:
16941 
          iprot.skip(ftype)
16942 
      else:
16943 
        iprot.skip(ftype)
16944 
      iprot.readFieldEnd()
16945 
    iprot.readStructEnd()
16946 
 
16947 
  def write(self, oprot):
16948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16950 
      return
16951 
    oprot.writeStructBegin('searchItemsInRange_args')
16952 
    if self.searchTerms is not None:
16953 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16954 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16955 
      for iter331 in self.searchTerms:
16956 
        oprot.writeString(iter331)
5944 mandeep.dh 16957 
      oprot.writeListEnd()
16958 
      oprot.writeFieldEnd()
16959 
    if self.offset is not None:
16960 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16961 
      oprot.writeI64(self.offset)
16962 
      oprot.writeFieldEnd()
16963 
    if self.limit is not None:
16964 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16965 
      oprot.writeI64(self.limit)
16966 
      oprot.writeFieldEnd()
16967 
    oprot.writeFieldStop()
16968 
    oprot.writeStructEnd()
16969 
 
16970 
  def validate(self):
16971 
    return
16972 
 
16973 
 
16974 
  def __repr__(self):
16975 
    L = ['%s=%r' % (key, value)
16976 
      for key, value in self.__dict__.iteritems()]
16977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16978 
 
16979 
  def __eq__(self, other):
16980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16981 
 
16982 
  def __ne__(self, other):
16983 
    return not (self == other)
16984 
 
16985 
class searchItemsInRange_result:
16986 
  """
16987 
  Attributes:
16988 
   - success
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16993 
  )
16994 
 
16995 
  def __init__(self, success=None,):
16996 
    self.success = success
16997 
 
16998 
  def read(self, iprot):
16999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17001 
      return
17002 
    iprot.readStructBegin()
17003 
    while True:
17004 
      (fname, ftype, fid) = iprot.readFieldBegin()
17005 
      if ftype == TType.STOP:
17006 
        break
17007 
      if fid == 0:
17008 
        if ftype == TType.LIST:
17009 
          self.success = []
9155 kshitij.so 17010 
          (_etype335, _size332) = iprot.readListBegin()
17011 
          for _i336 in xrange(_size332):
17012 
            _elem337 = Item()
17013 
            _elem337.read(iprot)
17014 
            self.success.append(_elem337)
5944 mandeep.dh 17015 
          iprot.readListEnd()
17016 
        else:
17017 
          iprot.skip(ftype)
17018 
      else:
17019 
        iprot.skip(ftype)
17020 
      iprot.readFieldEnd()
17021 
    iprot.readStructEnd()
17022 
 
17023 
  def write(self, oprot):
17024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17026 
      return
17027 
    oprot.writeStructBegin('searchItemsInRange_result')
17028 
    if self.success is not None:
17029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17031 
      for iter338 in self.success:
17032 
        iter338.write(oprot)
5944 mandeep.dh 17033 
      oprot.writeListEnd()
17034 
      oprot.writeFieldEnd()
17035 
    oprot.writeFieldStop()
17036 
    oprot.writeStructEnd()
17037 
 
17038 
  def validate(self):
17039 
    return
17040 
 
17041 
 
17042 
  def __repr__(self):
17043 
    L = ['%s=%r' % (key, value)
17044 
      for key, value in self.__dict__.iteritems()]
17045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17046 
 
17047 
  def __eq__(self, other):
17048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17049 
 
17050 
  def __ne__(self, other):
17051 
    return not (self == other)
17052 
 
17053 
class getSearchResultCount_args:
17054 
  """
17055 
  Attributes:
17056 
   - searchTerms
17057 
  """
17058 
 
17059 
  thrift_spec = (
17060 
    None, # 0
17061 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17062 
  )
17063 
 
17064 
  def __init__(self, searchTerms=None,):
17065 
    self.searchTerms = searchTerms
17066 
 
17067 
  def read(self, iprot):
17068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17070 
      return
17071 
    iprot.readStructBegin()
17072 
    while True:
17073 
      (fname, ftype, fid) = iprot.readFieldBegin()
17074 
      if ftype == TType.STOP:
17075 
        break
17076 
      if fid == 1:
17077 
        if ftype == TType.LIST:
17078 
          self.searchTerms = []
9155 kshitij.so 17079 
          (_etype342, _size339) = iprot.readListBegin()
17080 
          for _i343 in xrange(_size339):
17081 
            _elem344 = iprot.readString();
17082 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17083 
          iprot.readListEnd()
17084 
        else:
17085 
          iprot.skip(ftype)
17086 
      else:
17087 
        iprot.skip(ftype)
17088 
      iprot.readFieldEnd()
17089 
    iprot.readStructEnd()
17090 
 
17091 
  def write(self, oprot):
17092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17094 
      return
17095 
    oprot.writeStructBegin('getSearchResultCount_args')
17096 
    if self.searchTerms is not None:
17097 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17098 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17099 
      for iter345 in self.searchTerms:
17100 
        oprot.writeString(iter345)
5944 mandeep.dh 17101 
      oprot.writeListEnd()
17102 
      oprot.writeFieldEnd()
17103 
    oprot.writeFieldStop()
17104 
    oprot.writeStructEnd()
17105 
 
17106 
  def validate(self):
17107 
    return
17108 
 
17109 
 
17110 
  def __repr__(self):
17111 
    L = ['%s=%r' % (key, value)
17112 
      for key, value in self.__dict__.iteritems()]
17113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17114 
 
17115 
  def __eq__(self, other):
17116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17117 
 
17118 
  def __ne__(self, other):
17119 
    return not (self == other)
17120 
 
17121 
class getSearchResultCount_result:
17122 
  """
17123 
  Attributes:
17124 
   - success
17125 
  """
17126 
 
17127 
  thrift_spec = (
17128 
    (0, TType.I32, 'success', None, None, ), # 0
17129 
  )
17130 
 
17131 
  def __init__(self, success=None,):
17132 
    self.success = success
17133 
 
17134 
  def read(self, iprot):
17135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17137 
      return
17138 
    iprot.readStructBegin()
17139 
    while True:
17140 
      (fname, ftype, fid) = iprot.readFieldBegin()
17141 
      if ftype == TType.STOP:
17142 
        break
17143 
      if fid == 0:
17144 
        if ftype == TType.I32:
17145 
          self.success = iprot.readI32();
17146 
        else:
17147 
          iprot.skip(ftype)
17148 
      else:
17149 
        iprot.skip(ftype)
17150 
      iprot.readFieldEnd()
17151 
    iprot.readStructEnd()
17152 
 
17153 
  def write(self, oprot):
17154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17156 
      return
17157 
    oprot.writeStructBegin('getSearchResultCount_result')
17158 
    if self.success is not None:
17159 
      oprot.writeFieldBegin('success', TType.I32, 0)
17160 
      oprot.writeI32(self.success)
17161 
      oprot.writeFieldEnd()
17162 
    oprot.writeFieldStop()
17163 
    oprot.writeStructEnd()
17164 
 
17165 
  def validate(self):
17166 
    return
17167 
 
17168 
 
17169 
  def __repr__(self):
17170 
    L = ['%s=%r' % (key, value)
17171 
      for key, value in self.__dict__.iteritems()]
17172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17173 
 
17174 
  def __eq__(self, other):
17175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17176 
 
17177 
  def __ne__(self, other):
17178 
    return not (self == other)
17179 
 
17180 
class getProductNotifications_args:
17181 
  """
17182 
  Attributes:
17183 
   - startDateTime
17184 
  """
17185 
 
17186 
  thrift_spec = (
17187 
    None, # 0
17188 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17189 
  )
17190 
 
17191 
  def __init__(self, startDateTime=None,):
17192 
    self.startDateTime = startDateTime
17193 
 
17194 
  def read(self, iprot):
17195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17197 
      return
17198 
    iprot.readStructBegin()
17199 
    while True:
17200 
      (fname, ftype, fid) = iprot.readFieldBegin()
17201 
      if ftype == TType.STOP:
17202 
        break
17203 
      if fid == 1:
17204 
        if ftype == TType.I64:
17205 
          self.startDateTime = iprot.readI64();
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      else:
17209 
        iprot.skip(ftype)
17210 
      iprot.readFieldEnd()
17211 
    iprot.readStructEnd()
17212 
 
17213 
  def write(self, oprot):
17214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17216 
      return
17217 
    oprot.writeStructBegin('getProductNotifications_args')
17218 
    if self.startDateTime is not None:
17219 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17220 
      oprot.writeI64(self.startDateTime)
17221 
      oprot.writeFieldEnd()
17222 
    oprot.writeFieldStop()
17223 
    oprot.writeStructEnd()
17224 
 
17225 
  def validate(self):
17226 
    return
17227 
 
17228 
 
17229 
  def __repr__(self):
17230 
    L = ['%s=%r' % (key, value)
17231 
      for key, value in self.__dict__.iteritems()]
17232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17233 
 
17234 
  def __eq__(self, other):
17235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17236 
 
17237 
  def __ne__(self, other):
17238 
    return not (self == other)
17239 
 
17240 
class getProductNotifications_result:
17241 
  """
17242 
  Attributes:
17243 
   - success
17244 
  """
17245 
 
17246 
  thrift_spec = (
17247 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17248 
  )
17249 
 
17250 
  def __init__(self, success=None,):
17251 
    self.success = success
17252 
 
17253 
  def read(self, iprot):
17254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17256 
      return
17257 
    iprot.readStructBegin()
17258 
    while True:
17259 
      (fname, ftype, fid) = iprot.readFieldBegin()
17260 
      if ftype == TType.STOP:
17261 
        break
17262 
      if fid == 0:
17263 
        if ftype == TType.LIST:
17264 
          self.success = []
9155 kshitij.so 17265 
          (_etype349, _size346) = iprot.readListBegin()
17266 
          for _i350 in xrange(_size346):
17267 
            _elem351 = ProductNotificationRequest()
17268 
            _elem351.read(iprot)
17269 
            self.success.append(_elem351)
5944 mandeep.dh 17270 
          iprot.readListEnd()
17271 
        else:
17272 
          iprot.skip(ftype)
17273 
      else:
17274 
        iprot.skip(ftype)
17275 
      iprot.readFieldEnd()
17276 
    iprot.readStructEnd()
17277 
 
17278 
  def write(self, oprot):
17279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17281 
      return
17282 
    oprot.writeStructBegin('getProductNotifications_result')
17283 
    if self.success is not None:
17284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17286 
      for iter352 in self.success:
17287 
        iter352.write(oprot)
5944 mandeep.dh 17288 
      oprot.writeListEnd()
17289 
      oprot.writeFieldEnd()
17290 
    oprot.writeFieldStop()
17291 
    oprot.writeStructEnd()
17292 
 
17293 
  def validate(self):
17294 
    return
17295 
 
17296 
 
17297 
  def __repr__(self):
17298 
    L = ['%s=%r' % (key, value)
17299 
      for key, value in self.__dict__.iteritems()]
17300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17301 
 
17302 
  def __eq__(self, other):
17303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17304 
 
17305 
  def __ne__(self, other):
17306 
    return not (self == other)
17307 
 
17308 
class getProductNotificationRequestCount_args:
17309 
  """
17310 
  Attributes:
17311 
   - startDateTime
7897 amar.kumar 17312 
   - categoryId
5944 mandeep.dh 17313 
  """
17314 
 
17315 
  thrift_spec = (
17316 
    None, # 0
17317 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17318 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17319 
  )
17320 
 
7897 amar.kumar 17321 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17322 
    self.startDateTime = startDateTime
7897 amar.kumar 17323 
    self.categoryId = categoryId
5944 mandeep.dh 17324 
 
17325 
  def read(self, iprot):
17326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17328 
      return
17329 
    iprot.readStructBegin()
17330 
    while True:
17331 
      (fname, ftype, fid) = iprot.readFieldBegin()
17332 
      if ftype == TType.STOP:
17333 
        break
17334 
      if fid == 1:
17335 
        if ftype == TType.I64:
17336 
          self.startDateTime = iprot.readI64();
17337 
        else:
17338 
          iprot.skip(ftype)
7897 amar.kumar 17339 
      elif fid == 2:
17340 
        if ftype == TType.I64:
17341 
          self.categoryId = iprot.readI64();
17342 
        else:
17343 
          iprot.skip(ftype)
5944 mandeep.dh 17344 
      else:
17345 
        iprot.skip(ftype)
17346 
      iprot.readFieldEnd()
17347 
    iprot.readStructEnd()
17348 
 
17349 
  def write(self, oprot):
17350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17352 
      return
17353 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17354 
    if self.startDateTime is not None:
17355 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17356 
      oprot.writeI64(self.startDateTime)
17357 
      oprot.writeFieldEnd()
7897 amar.kumar 17358 
    if self.categoryId is not None:
17359 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17360 
      oprot.writeI64(self.categoryId)
17361 
      oprot.writeFieldEnd()
5944 mandeep.dh 17362 
    oprot.writeFieldStop()
17363 
    oprot.writeStructEnd()
17364 
 
17365 
  def validate(self):
17366 
    return
17367 
 
17368 
 
17369 
  def __repr__(self):
17370 
    L = ['%s=%r' % (key, value)
17371 
      for key, value in self.__dict__.iteritems()]
17372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17373 
 
17374 
  def __eq__(self, other):
17375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17376 
 
17377 
  def __ne__(self, other):
17378 
    return not (self == other)
17379 
 
17380 
class getProductNotificationRequestCount_result:
17381 
  """
17382 
  Attributes:
17383 
   - success
17384 
  """
17385 
 
17386 
  thrift_spec = (
17387 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17388 
  )
17389 
 
17390 
  def __init__(self, success=None,):
17391 
    self.success = success
17392 
 
17393 
  def read(self, iprot):
17394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17396 
      return
17397 
    iprot.readStructBegin()
17398 
    while True:
17399 
      (fname, ftype, fid) = iprot.readFieldBegin()
17400 
      if ftype == TType.STOP:
17401 
        break
17402 
      if fid == 0:
17403 
        if ftype == TType.LIST:
17404 
          self.success = []
9155 kshitij.so 17405 
          (_etype356, _size353) = iprot.readListBegin()
17406 
          for _i357 in xrange(_size353):
17407 
            _elem358 = ProductNotificationRequestCount()
17408 
            _elem358.read(iprot)
17409 
            self.success.append(_elem358)
5944 mandeep.dh 17410 
          iprot.readListEnd()
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      else:
17414 
        iprot.skip(ftype)
17415 
      iprot.readFieldEnd()
17416 
    iprot.readStructEnd()
17417 
 
17418 
  def write(self, oprot):
17419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17421 
      return
17422 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17423 
    if self.success is not None:
17424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17426 
      for iter359 in self.success:
17427 
        iter359.write(oprot)
5944 mandeep.dh 17428 
      oprot.writeListEnd()
17429 
      oprot.writeFieldEnd()
17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class addAuthorizationLog_args:
17449 
  """
17450 
  Attributes:
17451 
   - itemId
17452 
   - username
17453 
   - reason
17454 
  """
17455 
 
17456 
  thrift_spec = (
17457 
    None, # 0
17458 
    (1, TType.I64, 'itemId', None, None, ), # 1
17459 
    (2, TType.STRING, 'username', None, None, ), # 2
17460 
    (3, TType.STRING, 'reason', None, None, ), # 3
17461 
  )
17462 
 
17463 
  def __init__(self, itemId=None, username=None, reason=None,):
17464 
    self.itemId = itemId
17465 
    self.username = username
17466 
    self.reason = reason
17467 
 
17468 
  def read(self, iprot):
17469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17471 
      return
17472 
    iprot.readStructBegin()
17473 
    while True:
17474 
      (fname, ftype, fid) = iprot.readFieldBegin()
17475 
      if ftype == TType.STOP:
17476 
        break
17477 
      if fid == 1:
17478 
        if ftype == TType.I64:
17479 
          self.itemId = iprot.readI64();
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      elif fid == 2:
17483 
        if ftype == TType.STRING:
17484 
          self.username = iprot.readString();
17485 
        else:
17486 
          iprot.skip(ftype)
17487 
      elif fid == 3:
17488 
        if ftype == TType.STRING:
17489 
          self.reason = iprot.readString();
17490 
        else:
17491 
          iprot.skip(ftype)
17492 
      else:
17493 
        iprot.skip(ftype)
17494 
      iprot.readFieldEnd()
17495 
    iprot.readStructEnd()
17496 
 
17497 
  def write(self, oprot):
17498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17500 
      return
17501 
    oprot.writeStructBegin('addAuthorizationLog_args')
17502 
    if self.itemId is not None:
17503 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17504 
      oprot.writeI64(self.itemId)
17505 
      oprot.writeFieldEnd()
17506 
    if self.username is not None:
17507 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17508 
      oprot.writeString(self.username)
17509 
      oprot.writeFieldEnd()
17510 
    if self.reason is not None:
17511 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17512 
      oprot.writeString(self.reason)
17513 
      oprot.writeFieldEnd()
17514 
    oprot.writeFieldStop()
17515 
    oprot.writeStructEnd()
17516 
 
17517 
  def validate(self):
17518 
    return
17519 
 
17520 
 
17521 
  def __repr__(self):
17522 
    L = ['%s=%r' % (key, value)
17523 
      for key, value in self.__dict__.iteritems()]
17524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17525 
 
17526 
  def __eq__(self, other):
17527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17528 
 
17529 
  def __ne__(self, other):
17530 
    return not (self == other)
17531 
 
17532 
class addAuthorizationLog_result:
17533 
  """
17534 
  Attributes:
17535 
   - success
17536 
   - cex
17537 
  """
17538 
 
17539 
  thrift_spec = (
17540 
    (0, TType.BOOL, 'success', None, None, ), # 0
17541 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17542 
  )
17543 
 
17544 
  def __init__(self, success=None, cex=None,):
17545 
    self.success = success
17546 
    self.cex = cex
17547 
 
17548 
  def read(self, iprot):
17549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17551 
      return
17552 
    iprot.readStructBegin()
17553 
    while True:
17554 
      (fname, ftype, fid) = iprot.readFieldBegin()
17555 
      if ftype == TType.STOP:
17556 
        break
17557 
      if fid == 0:
17558 
        if ftype == TType.BOOL:
17559 
          self.success = iprot.readBool();
17560 
        else:
17561 
          iprot.skip(ftype)
17562 
      elif fid == 1:
17563 
        if ftype == TType.STRUCT:
17564 
          self.cex = CatalogServiceException()
17565 
          self.cex.read(iprot)
17566 
        else:
17567 
          iprot.skip(ftype)
17568 
      else:
17569 
        iprot.skip(ftype)
17570 
      iprot.readFieldEnd()
17571 
    iprot.readStructEnd()
17572 
 
17573 
  def write(self, oprot):
17574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17576 
      return
17577 
    oprot.writeStructBegin('addAuthorizationLog_result')
17578 
    if self.success is not None:
17579 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17580 
      oprot.writeBool(self.success)
17581 
      oprot.writeFieldEnd()
17582 
    if self.cex is not None:
17583 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17584 
      self.cex.write(oprot)
17585 
      oprot.writeFieldEnd()
17586 
    oprot.writeFieldStop()
17587 
    oprot.writeStructEnd()
17588 
 
17589 
  def validate(self):
17590 
    return
17591 
 
17592 
 
17593 
  def __repr__(self):
17594 
    L = ['%s=%r' % (key, value)
17595 
      for key, value in self.__dict__.iteritems()]
17596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17597 
 
17598 
  def __eq__(self, other):
17599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17600 
 
17601 
  def __ne__(self, other):
17602 
    return not (self == other)
17603 
 
17604 
class addupdateVoucherForItem_args:
17605 
  """
17606 
  Attributes:
17607 
   - catalog_item_id
17608 
   - voucherType
17609 
   - voucherAmount
17610 
  """
17611 
 
17612 
  thrift_spec = (
17613 
    None, # 0
17614 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17615 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17616 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17617 
  )
17618 
 
17619 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17620 
    self.catalog_item_id = catalog_item_id
17621 
    self.voucherType = voucherType
17622 
    self.voucherAmount = voucherAmount
17623 
 
17624 
  def read(self, iprot):
17625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17627 
      return
17628 
    iprot.readStructBegin()
17629 
    while True:
17630 
      (fname, ftype, fid) = iprot.readFieldBegin()
17631 
      if ftype == TType.STOP:
17632 
        break
17633 
      if fid == 1:
17634 
        if ftype == TType.I64:
17635 
          self.catalog_item_id = iprot.readI64();
17636 
        else:
17637 
          iprot.skip(ftype)
17638 
      elif fid == 2:
17639 
        if ftype == TType.I64:
17640 
          self.voucherType = iprot.readI64();
17641 
        else:
17642 
          iprot.skip(ftype)
17643 
      elif fid == 3:
17644 
        if ftype == TType.I64:
17645 
          self.voucherAmount = iprot.readI64();
17646 
        else:
17647 
          iprot.skip(ftype)
17648 
      else:
17649 
        iprot.skip(ftype)
17650 
      iprot.readFieldEnd()
17651 
    iprot.readStructEnd()
17652 
 
17653 
  def write(self, oprot):
17654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17656 
      return
17657 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17658 
    if self.catalog_item_id is not None:
17659 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17660 
      oprot.writeI64(self.catalog_item_id)
17661 
      oprot.writeFieldEnd()
17662 
    if self.voucherType is not None:
17663 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17664 
      oprot.writeI64(self.voucherType)
17665 
      oprot.writeFieldEnd()
17666 
    if self.voucherAmount is not None:
17667 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17668 
      oprot.writeI64(self.voucherAmount)
17669 
      oprot.writeFieldEnd()
17670 
    oprot.writeFieldStop()
17671 
    oprot.writeStructEnd()
17672 
 
17673 
  def validate(self):
17674 
    return
17675 
 
17676 
 
17677 
  def __repr__(self):
17678 
    L = ['%s=%r' % (key, value)
17679 
      for key, value in self.__dict__.iteritems()]
17680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17681 
 
17682 
  def __eq__(self, other):
17683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17684 
 
17685 
  def __ne__(self, other):
17686 
    return not (self == other)
17687 
 
17688 
class addupdateVoucherForItem_result:
17689 
  """
17690 
  Attributes:
17691 
   - success
17692 
   - cex
17693 
  """
17694 
 
17695 
  thrift_spec = (
17696 
    (0, TType.BOOL, 'success', None, None, ), # 0
17697 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17698 
  )
17699 
 
17700 
  def __init__(self, success=None, cex=None,):
17701 
    self.success = success
17702 
    self.cex = cex
17703 
 
17704 
  def read(self, iprot):
17705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17707 
      return
17708 
    iprot.readStructBegin()
17709 
    while True:
17710 
      (fname, ftype, fid) = iprot.readFieldBegin()
17711 
      if ftype == TType.STOP:
17712 
        break
17713 
      if fid == 0:
17714 
        if ftype == TType.BOOL:
17715 
          self.success = iprot.readBool();
17716 
        else:
17717 
          iprot.skip(ftype)
17718 
      elif fid == 1:
17719 
        if ftype == TType.STRUCT:
17720 
          self.cex = CatalogServiceException()
17721 
          self.cex.read(iprot)
17722 
        else:
17723 
          iprot.skip(ftype)
17724 
      else:
17725 
        iprot.skip(ftype)
17726 
      iprot.readFieldEnd()
17727 
    iprot.readStructEnd()
17728 
 
17729 
  def write(self, oprot):
17730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17732 
      return
17733 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17734 
    if self.success is not None:
17735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17736 
      oprot.writeBool(self.success)
17737 
      oprot.writeFieldEnd()
17738 
    if self.cex is not None:
17739 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17740 
      self.cex.write(oprot)
17741 
      oprot.writeFieldEnd()
17742 
    oprot.writeFieldStop()
17743 
    oprot.writeStructEnd()
17744 
 
17745 
  def validate(self):
17746 
    return
17747 
 
17748 
 
17749 
  def __repr__(self):
17750 
    L = ['%s=%r' % (key, value)
17751 
      for key, value in self.__dict__.iteritems()]
17752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17753 
 
17754 
  def __eq__(self, other):
17755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17756 
 
17757 
  def __ne__(self, other):
17758 
    return not (self == other)
17759 
 
17760 
class deleteVoucherForItem_args:
17761 
  """
17762 
  Attributes:
17763 
   - catalog_item_id
17764 
   - voucherType
17765 
  """
17766 
 
17767 
  thrift_spec = (
17768 
    None, # 0
17769 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17770 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17771 
  )
17772 
 
17773 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17774 
    self.catalog_item_id = catalog_item_id
17775 
    self.voucherType = voucherType
17776 
 
17777 
  def read(self, iprot):
17778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17780 
      return
17781 
    iprot.readStructBegin()
17782 
    while True:
17783 
      (fname, ftype, fid) = iprot.readFieldBegin()
17784 
      if ftype == TType.STOP:
17785 
        break
17786 
      if fid == 1:
17787 
        if ftype == TType.I64:
17788 
          self.catalog_item_id = iprot.readI64();
17789 
        else:
17790 
          iprot.skip(ftype)
17791 
      elif fid == 2:
17792 
        if ftype == TType.I64:
17793 
          self.voucherType = iprot.readI64();
17794 
        else:
17795 
          iprot.skip(ftype)
17796 
      else:
17797 
        iprot.skip(ftype)
17798 
      iprot.readFieldEnd()
17799 
    iprot.readStructEnd()
17800 
 
17801 
  def write(self, oprot):
17802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17804 
      return
17805 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17806 
    if self.catalog_item_id is not None:
17807 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17808 
      oprot.writeI64(self.catalog_item_id)
17809 
      oprot.writeFieldEnd()
17810 
    if self.voucherType is not None:
17811 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17812 
      oprot.writeI64(self.voucherType)
17813 
      oprot.writeFieldEnd()
17814 
    oprot.writeFieldStop()
17815 
    oprot.writeStructEnd()
17816 
 
17817 
  def validate(self):
17818 
    return
17819 
 
17820 
 
17821 
  def __repr__(self):
17822 
    L = ['%s=%r' % (key, value)
17823 
      for key, value in self.__dict__.iteritems()]
17824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17825 
 
17826 
  def __eq__(self, other):
17827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17828 
 
17829 
  def __ne__(self, other):
17830 
    return not (self == other)
17831 
 
17832 
class deleteVoucherForItem_result:
17833 
  """
17834 
  Attributes:
17835 
   - success
17836 
   - cex
17837 
  """
17838 
 
17839 
  thrift_spec = (
17840 
    (0, TType.BOOL, 'success', None, None, ), # 0
17841 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17842 
  )
17843 
 
17844 
  def __init__(self, success=None, cex=None,):
17845 
    self.success = success
17846 
    self.cex = cex
17847 
 
17848 
  def read(self, iprot):
17849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17851 
      return
17852 
    iprot.readStructBegin()
17853 
    while True:
17854 
      (fname, ftype, fid) = iprot.readFieldBegin()
17855 
      if ftype == TType.STOP:
17856 
        break
17857 
      if fid == 0:
17858 
        if ftype == TType.BOOL:
17859 
          self.success = iprot.readBool();
17860 
        else:
17861 
          iprot.skip(ftype)
17862 
      elif fid == 1:
17863 
        if ftype == TType.STRUCT:
17864 
          self.cex = CatalogServiceException()
17865 
          self.cex.read(iprot)
17866 
        else:
17867 
          iprot.skip(ftype)
17868 
      else:
17869 
        iprot.skip(ftype)
17870 
      iprot.readFieldEnd()
17871 
    iprot.readStructEnd()
17872 
 
17873 
  def write(self, oprot):
17874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17876 
      return
17877 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17878 
    if self.success is not None:
17879 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17880 
      oprot.writeBool(self.success)
17881 
      oprot.writeFieldEnd()
17882 
    if self.cex is not None:
17883 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17884 
      self.cex.write(oprot)
17885 
      oprot.writeFieldEnd()
17886 
    oprot.writeFieldStop()
17887 
    oprot.writeStructEnd()
17888 
 
17889 
  def validate(self):
17890 
    return
17891 
 
17892 
 
17893 
  def __repr__(self):
17894 
    L = ['%s=%r' % (key, value)
17895 
      for key, value in self.__dict__.iteritems()]
17896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17897 
 
17898 
  def __eq__(self, other):
17899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17900 
 
17901 
  def __ne__(self, other):
17902 
    return not (self == other)
17903 
 
17904 
class getVoucherAmount_args:
17905 
  """
17906 
  Attributes:
17907 
   - itemId
17908 
   - voucherType
17909 
  """
17910 
 
17911 
  thrift_spec = (
17912 
    None, # 0
17913 
    (1, TType.I64, 'itemId', None, None, ), # 1
17914 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17915 
  )
17916 
 
17917 
  def __init__(self, itemId=None, voucherType=None,):
17918 
    self.itemId = itemId
17919 
    self.voucherType = voucherType
17920 
 
17921 
  def read(self, iprot):
17922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17924 
      return
17925 
    iprot.readStructBegin()
17926 
    while True:
17927 
      (fname, ftype, fid) = iprot.readFieldBegin()
17928 
      if ftype == TType.STOP:
17929 
        break
17930 
      if fid == 1:
17931 
        if ftype == TType.I64:
17932 
          self.itemId = iprot.readI64();
17933 
        else:
17934 
          iprot.skip(ftype)
17935 
      elif fid == 2:
17936 
        if ftype == TType.I64:
17937 
          self.voucherType = iprot.readI64();
17938 
        else:
17939 
          iprot.skip(ftype)
17940 
      else:
17941 
        iprot.skip(ftype)
17942 
      iprot.readFieldEnd()
17943 
    iprot.readStructEnd()
17944 
 
17945 
  def write(self, oprot):
17946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17948 
      return
17949 
    oprot.writeStructBegin('getVoucherAmount_args')
17950 
    if self.itemId is not None:
17951 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17952 
      oprot.writeI64(self.itemId)
17953 
      oprot.writeFieldEnd()
17954 
    if self.voucherType is not None:
17955 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17956 
      oprot.writeI64(self.voucherType)
17957 
      oprot.writeFieldEnd()
17958 
    oprot.writeFieldStop()
17959 
    oprot.writeStructEnd()
17960 
 
17961 
  def validate(self):
17962 
    return
17963 
 
17964 
 
17965 
  def __repr__(self):
17966 
    L = ['%s=%r' % (key, value)
17967 
      for key, value in self.__dict__.iteritems()]
17968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17969 
 
17970 
  def __eq__(self, other):
17971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17972 
 
17973 
  def __ne__(self, other):
17974 
    return not (self == other)
17975 
 
17976 
class getVoucherAmount_result:
17977 
  """
17978 
  Attributes:
17979 
   - success
17980 
  """
17981 
 
17982 
  thrift_spec = (
17983 
    (0, TType.I64, 'success', None, None, ), # 0
17984 
  )
17985 
 
17986 
  def __init__(self, success=None,):
17987 
    self.success = success
17988 
 
17989 
  def read(self, iprot):
17990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17992 
      return
17993 
    iprot.readStructBegin()
17994 
    while True:
17995 
      (fname, ftype, fid) = iprot.readFieldBegin()
17996 
      if ftype == TType.STOP:
17997 
        break
17998 
      if fid == 0:
17999 
        if ftype == TType.I64:
18000 
          self.success = iprot.readI64();
18001 
        else:
18002 
          iprot.skip(ftype)
18003 
      else:
18004 
        iprot.skip(ftype)
18005 
      iprot.readFieldEnd()
18006 
    iprot.readStructEnd()
18007 
 
18008 
  def write(self, oprot):
18009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18011 
      return
18012 
    oprot.writeStructBegin('getVoucherAmount_result')
18013 
    if self.success is not None:
18014 
      oprot.writeFieldBegin('success', TType.I64, 0)
18015 
      oprot.writeI64(self.success)
18016 
      oprot.writeFieldEnd()
18017 
    oprot.writeFieldStop()
18018 
    oprot.writeStructEnd()
18019 
 
18020 
  def validate(self):
18021 
    return
18022 
 
18023 
 
18024 
  def __repr__(self):
18025 
    L = ['%s=%r' % (key, value)
18026 
      for key, value in self.__dict__.iteritems()]
18027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18028 
 
18029 
  def __eq__(self, other):
18030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18031 
 
18032 
  def __ne__(self, other):
18033 
    return not (self == other)
18034 
 
18035 
class getAllItemVouchers_args:
18036 
  """
18037 
  Attributes:
18038 
   - itemId
18039 
  """
18040 
 
18041 
  thrift_spec = (
18042 
    None, # 0
18043 
    (1, TType.I64, 'itemId', None, None, ), # 1
18044 
  )
18045 
 
18046 
  def __init__(self, itemId=None,):
18047 
    self.itemId = itemId
18048 
 
18049 
  def read(self, iprot):
18050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18052 
      return
18053 
    iprot.readStructBegin()
18054 
    while True:
18055 
      (fname, ftype, fid) = iprot.readFieldBegin()
18056 
      if ftype == TType.STOP:
18057 
        break
18058 
      if fid == 1:
18059 
        if ftype == TType.I64:
18060 
          self.itemId = iprot.readI64();
18061 
        else:
18062 
          iprot.skip(ftype)
18063 
      else:
18064 
        iprot.skip(ftype)
18065 
      iprot.readFieldEnd()
18066 
    iprot.readStructEnd()
18067 
 
18068 
  def write(self, oprot):
18069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18071 
      return
18072 
    oprot.writeStructBegin('getAllItemVouchers_args')
18073 
    if self.itemId is not None:
18074 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18075 
      oprot.writeI64(self.itemId)
18076 
      oprot.writeFieldEnd()
18077 
    oprot.writeFieldStop()
18078 
    oprot.writeStructEnd()
18079 
 
18080 
  def validate(self):
18081 
    return
18082 
 
18083 
 
18084 
  def __repr__(self):
18085 
    L = ['%s=%r' % (key, value)
18086 
      for key, value in self.__dict__.iteritems()]
18087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18088 
 
18089 
  def __eq__(self, other):
18090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18091 
 
18092 
  def __ne__(self, other):
18093 
    return not (self == other)
18094 
 
18095 
class getAllItemVouchers_result:
18096 
  """
18097 
  Attributes:
18098 
   - success
18099 
  """
18100 
 
18101 
  thrift_spec = (
18102 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18103 
  )
18104 
 
18105 
  def __init__(self, success=None,):
18106 
    self.success = success
18107 
 
18108 
  def read(self, iprot):
18109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18111 
      return
18112 
    iprot.readStructBegin()
18113 
    while True:
18114 
      (fname, ftype, fid) = iprot.readFieldBegin()
18115 
      if ftype == TType.STOP:
18116 
        break
18117 
      if fid == 0:
18118 
        if ftype == TType.LIST:
18119 
          self.success = []
9155 kshitij.so 18120 
          (_etype363, _size360) = iprot.readListBegin()
18121 
          for _i364 in xrange(_size360):
18122 
            _elem365 = VoucherItemMapping()
18123 
            _elem365.read(iprot)
18124 
            self.success.append(_elem365)
5944 mandeep.dh 18125 
          iprot.readListEnd()
18126 
        else:
18127 
          iprot.skip(ftype)
18128 
      else:
18129 
        iprot.skip(ftype)
18130 
      iprot.readFieldEnd()
18131 
    iprot.readStructEnd()
18132 
 
18133 
  def write(self, oprot):
18134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18136 
      return
18137 
    oprot.writeStructBegin('getAllItemVouchers_result')
18138 
    if self.success is not None:
18139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18141 
      for iter366 in self.success:
18142 
        iter366.write(oprot)
5944 mandeep.dh 18143 
      oprot.writeListEnd()
18144 
      oprot.writeFieldEnd()
18145 
    oprot.writeFieldStop()
18146 
    oprot.writeStructEnd()
18147 
 
18148 
  def validate(self):
18149 
    return
18150 
 
18151 
 
18152 
  def __repr__(self):
18153 
    L = ['%s=%r' % (key, value)
18154 
      for key, value in self.__dict__.iteritems()]
18155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18156 
 
18157 
  def __eq__(self, other):
18158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18159 
 
18160 
  def __ne__(self, other):
18161 
    return not (self == other)
18162 
 
18163 
class isValidCatalogItemId_args:
18164 
  """
18165 
  Attributes:
18166 
   - catalog_item_id
18167 
  """
18168 
 
18169 
  thrift_spec = (
18170 
    None, # 0
18171 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18172 
  )
18173 
 
18174 
  def __init__(self, catalog_item_id=None,):
18175 
    self.catalog_item_id = catalog_item_id
18176 
 
18177 
  def read(self, iprot):
18178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18180 
      return
18181 
    iprot.readStructBegin()
18182 
    while True:
18183 
      (fname, ftype, fid) = iprot.readFieldBegin()
18184 
      if ftype == TType.STOP:
18185 
        break
18186 
      if fid == 1:
18187 
        if ftype == TType.I64:
18188 
          self.catalog_item_id = iprot.readI64();
18189 
        else:
18190 
          iprot.skip(ftype)
18191 
      else:
18192 
        iprot.skip(ftype)
18193 
      iprot.readFieldEnd()
18194 
    iprot.readStructEnd()
18195 
 
18196 
  def write(self, oprot):
18197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18199 
      return
18200 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18201 
    if self.catalog_item_id is not None:
18202 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18203 
      oprot.writeI64(self.catalog_item_id)
18204 
      oprot.writeFieldEnd()
18205 
    oprot.writeFieldStop()
18206 
    oprot.writeStructEnd()
18207 
 
18208 
  def validate(self):
18209 
    return
18210 
 
18211 
 
18212 
  def __repr__(self):
18213 
    L = ['%s=%r' % (key, value)
18214 
      for key, value in self.__dict__.iteritems()]
18215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18216 
 
18217 
  def __eq__(self, other):
18218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18219 
 
18220 
  def __ne__(self, other):
18221 
    return not (self == other)
18222 
 
18223 
class isValidCatalogItemId_result:
18224 
  """
18225 
  Attributes:
18226 
   - success
18227 
  """
18228 
 
18229 
  thrift_spec = (
18230 
    (0, TType.BOOL, 'success', None, None, ), # 0
18231 
  )
18232 
 
18233 
  def __init__(self, success=None,):
18234 
    self.success = success
18235 
 
18236 
  def read(self, iprot):
18237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18239 
      return
18240 
    iprot.readStructBegin()
18241 
    while True:
18242 
      (fname, ftype, fid) = iprot.readFieldBegin()
18243 
      if ftype == TType.STOP:
18244 
        break
18245 
      if fid == 0:
18246 
        if ftype == TType.BOOL:
18247 
          self.success = iprot.readBool();
18248 
        else:
18249 
          iprot.skip(ftype)
18250 
      else:
18251 
        iprot.skip(ftype)
18252 
      iprot.readFieldEnd()
18253 
    iprot.readStructEnd()
18254 
 
18255 
  def write(self, oprot):
18256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18258 
      return
18259 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18260 
    if self.success is not None:
18261 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18262 
      oprot.writeBool(self.success)
18263 
      oprot.writeFieldEnd()
18264 
    oprot.writeFieldStop()
18265 
    oprot.writeStructEnd()
18266 
 
18267 
  def validate(self):
18268 
    return
18269 
 
18270 
 
18271 
  def __repr__(self):
18272 
    L = ['%s=%r' % (key, value)
18273 
      for key, value in self.__dict__.iteritems()]
18274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18275 
 
18276 
  def __eq__(self, other):
18277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18278 
 
18279 
  def __ne__(self, other):
18280 
    return not (self == other)
6039 amit.gupta 18281 
 
18282 
class getVatPercentageForItem_args:
18283 
  """
18284 
  Attributes:
18285 
   - itemId
7330 amit.gupta 18286 
   - stateId
6039 amit.gupta 18287 
   - price
18288 
  """
18289 
 
18290 
  thrift_spec = (
18291 
    None, # 0
18292 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18293 
    (2, TType.I64, 'stateId', None, None, ), # 2
18294 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18295 
  )
18296 
 
7330 amit.gupta 18297 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18298 
    self.itemId = itemId
7330 amit.gupta 18299 
    self.stateId = stateId
6039 amit.gupta 18300 
    self.price = price
18301 
 
18302 
  def read(self, iprot):
18303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18305 
      return
18306 
    iprot.readStructBegin()
18307 
    while True:
18308 
      (fname, ftype, fid) = iprot.readFieldBegin()
18309 
      if ftype == TType.STOP:
18310 
        break
18311 
      if fid == 1:
18312 
        if ftype == TType.I64:
18313 
          self.itemId = iprot.readI64();
18314 
        else:
18315 
          iprot.skip(ftype)
18316 
      elif fid == 2:
7330 amit.gupta 18317 
        if ftype == TType.I64:
18318 
          self.stateId = iprot.readI64();
18319 
        else:
18320 
          iprot.skip(ftype)
18321 
      elif fid == 3:
6039 amit.gupta 18322 
        if ftype == TType.DOUBLE:
18323 
          self.price = iprot.readDouble();
18324 
        else:
18325 
          iprot.skip(ftype)
18326 
      else:
18327 
        iprot.skip(ftype)
18328 
      iprot.readFieldEnd()
18329 
    iprot.readStructEnd()
18330 
 
18331 
  def write(self, oprot):
18332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18334 
      return
18335 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18336 
    if self.itemId is not None:
18337 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18338 
      oprot.writeI64(self.itemId)
18339 
      oprot.writeFieldEnd()
7330 amit.gupta 18340 
    if self.stateId is not None:
18341 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18342 
      oprot.writeI64(self.stateId)
18343 
      oprot.writeFieldEnd()
6039 amit.gupta 18344 
    if self.price is not None:
7330 amit.gupta 18345 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18346 
      oprot.writeDouble(self.price)
18347 
      oprot.writeFieldEnd()
18348 
    oprot.writeFieldStop()
18349 
    oprot.writeStructEnd()
18350 
 
18351 
  def validate(self):
18352 
    return
18353 
 
18354 
 
18355 
  def __repr__(self):
18356 
    L = ['%s=%r' % (key, value)
18357 
      for key, value in self.__dict__.iteritems()]
18358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18359 
 
18360 
  def __eq__(self, other):
18361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18362 
 
18363 
  def __ne__(self, other):
18364 
    return not (self == other)
18365 
 
18366 
class getVatPercentageForItem_result:
18367 
  """
18368 
  Attributes:
18369 
   - success
7340 amit.gupta 18370 
   - cex
6039 amit.gupta 18371 
  """
18372 
 
18373 
  thrift_spec = (
18374 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18375 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18376 
  )
18377 
 
7340 amit.gupta 18378 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18379 
    self.success = success
7340 amit.gupta 18380 
    self.cex = cex
6039 amit.gupta 18381 
 
18382 
  def read(self, iprot):
18383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18385 
      return
18386 
    iprot.readStructBegin()
18387 
    while True:
18388 
      (fname, ftype, fid) = iprot.readFieldBegin()
18389 
      if ftype == TType.STOP:
18390 
        break
18391 
      if fid == 0:
18392 
        if ftype == TType.DOUBLE:
18393 
          self.success = iprot.readDouble();
18394 
        else:
18395 
          iprot.skip(ftype)
7340 amit.gupta 18396 
      elif fid == 1:
18397 
        if ftype == TType.STRUCT:
18398 
          self.cex = CatalogServiceException()
18399 
          self.cex.read(iprot)
18400 
        else:
18401 
          iprot.skip(ftype)
6039 amit.gupta 18402 
      else:
18403 
        iprot.skip(ftype)
18404 
      iprot.readFieldEnd()
18405 
    iprot.readStructEnd()
18406 
 
18407 
  def write(self, oprot):
18408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18410 
      return
18411 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18412 
    if self.success is not None:
18413 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18414 
      oprot.writeDouble(self.success)
18415 
      oprot.writeFieldEnd()
7340 amit.gupta 18416 
    if self.cex is not None:
18417 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18418 
      self.cex.write(oprot)
18419 
      oprot.writeFieldEnd()
6039 amit.gupta 18420 
    oprot.writeFieldStop()
18421 
    oprot.writeStructEnd()
18422 
 
18423 
  def validate(self):
18424 
    return
18425 
 
18426 
 
18427 
  def __repr__(self):
18428 
    L = ['%s=%r' % (key, value)
18429 
      for key, value in self.__dict__.iteritems()]
18430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18431 
 
18432 
  def __eq__(self, other):
18433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18434 
 
18435 
  def __ne__(self, other):
18436 
    return not (self == other)
18437 
 
18438 
class getVatAmountForItem_args:
18439 
  """
18440 
  Attributes:
18441 
   - itemId
18442 
   - price
18443 
  """
18444 
 
18445 
  thrift_spec = (
18446 
    None, # 0
18447 
    (1, TType.I64, 'itemId', None, None, ), # 1
18448 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18449 
  )
18450 
 
18451 
  def __init__(self, itemId=None, price=None,):
18452 
    self.itemId = itemId
18453 
    self.price = price
18454 
 
18455 
  def read(self, iprot):
18456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18458 
      return
18459 
    iprot.readStructBegin()
18460 
    while True:
18461 
      (fname, ftype, fid) = iprot.readFieldBegin()
18462 
      if ftype == TType.STOP:
18463 
        break
18464 
      if fid == 1:
18465 
        if ftype == TType.I64:
18466 
          self.itemId = iprot.readI64();
18467 
        else:
18468 
          iprot.skip(ftype)
18469 
      elif fid == 2:
18470 
        if ftype == TType.DOUBLE:
18471 
          self.price = iprot.readDouble();
18472 
        else:
18473 
          iprot.skip(ftype)
18474 
      else:
18475 
        iprot.skip(ftype)
18476 
      iprot.readFieldEnd()
18477 
    iprot.readStructEnd()
18478 
 
18479 
  def write(self, oprot):
18480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18482 
      return
18483 
    oprot.writeStructBegin('getVatAmountForItem_args')
18484 
    if self.itemId is not None:
18485 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18486 
      oprot.writeI64(self.itemId)
18487 
      oprot.writeFieldEnd()
18488 
    if self.price is not None:
18489 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18490 
      oprot.writeDouble(self.price)
18491 
      oprot.writeFieldEnd()
18492 
    oprot.writeFieldStop()
18493 
    oprot.writeStructEnd()
18494 
 
18495 
  def validate(self):
18496 
    return
18497 
 
18498 
 
18499 
  def __repr__(self):
18500 
    L = ['%s=%r' % (key, value)
18501 
      for key, value in self.__dict__.iteritems()]
18502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18503 
 
18504 
  def __eq__(self, other):
18505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18506 
 
18507 
  def __ne__(self, other):
18508 
    return not (self == other)
18509 
 
18510 
class getVatAmountForItem_result:
18511 
  """
18512 
  Attributes:
18513 
   - success
18514 
  """
18515 
 
18516 
  thrift_spec = (
18517 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18518 
  )
18519 
 
18520 
  def __init__(self, success=None,):
18521 
    self.success = success
18522 
 
18523 
  def read(self, iprot):
18524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18526 
      return
18527 
    iprot.readStructBegin()
18528 
    while True:
18529 
      (fname, ftype, fid) = iprot.readFieldBegin()
18530 
      if ftype == TType.STOP:
18531 
        break
18532 
      if fid == 0:
18533 
        if ftype == TType.DOUBLE:
18534 
          self.success = iprot.readDouble();
18535 
        else:
18536 
          iprot.skip(ftype)
18537 
      else:
18538 
        iprot.skip(ftype)
18539 
      iprot.readFieldEnd()
18540 
    iprot.readStructEnd()
18541 
 
18542 
  def write(self, oprot):
18543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18545 
      return
18546 
    oprot.writeStructBegin('getVatAmountForItem_result')
18547 
    if self.success is not None:
18548 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18549 
      oprot.writeDouble(self.success)
18550 
      oprot.writeFieldEnd()
18551 
    oprot.writeFieldStop()
18552 
    oprot.writeStructEnd()
18553 
 
18554 
  def validate(self):
18555 
    return
18556 
 
18557 
 
18558 
  def __repr__(self):
18559 
    L = ['%s=%r' % (key, value)
18560 
      for key, value in self.__dict__.iteritems()]
18561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18562 
 
18563 
  def __eq__(self, other):
18564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18565 
 
18566 
  def __ne__(self, other):
18567 
    return not (self == other)
6531 vikram.rag 18568 
 
18569 
class getAllIgnoredInventoryUpdateItemsList_args:
18570 
  """
18571 
  Attributes:
18572 
   - offset
18573 
   - limit
18574 
  """
18575 
 
18576 
  thrift_spec = (
18577 
    None, # 0
18578 
    (1, TType.I32, 'offset', None, None, ), # 1
18579 
    (2, TType.I32, 'limit', None, None, ), # 2
18580 
  )
18581 
 
18582 
  def __init__(self, offset=None, limit=None,):
18583 
    self.offset = offset
18584 
    self.limit = limit
18585 
 
18586 
  def read(self, iprot):
18587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18589 
      return
18590 
    iprot.readStructBegin()
18591 
    while True:
18592 
      (fname, ftype, fid) = iprot.readFieldBegin()
18593 
      if ftype == TType.STOP:
18594 
        break
18595 
      if fid == 1:
18596 
        if ftype == TType.I32:
18597 
          self.offset = iprot.readI32();
18598 
        else:
18599 
          iprot.skip(ftype)
18600 
      elif fid == 2:
18601 
        if ftype == TType.I32:
18602 
          self.limit = iprot.readI32();
18603 
        else:
18604 
          iprot.skip(ftype)
18605 
      else:
18606 
        iprot.skip(ftype)
18607 
      iprot.readFieldEnd()
18608 
    iprot.readStructEnd()
18609 
 
18610 
  def write(self, oprot):
18611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18613 
      return
18614 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18615 
    if self.offset is not None:
18616 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18617 
      oprot.writeI32(self.offset)
18618 
      oprot.writeFieldEnd()
18619 
    if self.limit is not None:
18620 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18621 
      oprot.writeI32(self.limit)
18622 
      oprot.writeFieldEnd()
18623 
    oprot.writeFieldStop()
18624 
    oprot.writeStructEnd()
18625 
 
18626 
  def validate(self):
18627 
    return
18628 
 
18629 
 
18630 
  def __repr__(self):
18631 
    L = ['%s=%r' % (key, value)
18632 
      for key, value in self.__dict__.iteritems()]
18633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18634 
 
18635 
  def __eq__(self, other):
18636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18637 
 
18638 
  def __ne__(self, other):
18639 
    return not (self == other)
18640 
 
18641 
class getAllIgnoredInventoryUpdateItemsList_result:
18642 
  """
18643 
  Attributes:
18644 
   - success
18645 
  """
18646 
 
18647 
  thrift_spec = (
18648 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18649 
  )
18650 
 
18651 
  def __init__(self, success=None,):
18652 
    self.success = success
18653 
 
18654 
  def read(self, iprot):
18655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18657 
      return
18658 
    iprot.readStructBegin()
18659 
    while True:
18660 
      (fname, ftype, fid) = iprot.readFieldBegin()
18661 
      if ftype == TType.STOP:
18662 
        break
18663 
      if fid == 0:
18664 
        if ftype == TType.LIST:
18665 
          self.success = []
9155 kshitij.so 18666 
          (_etype370, _size367) = iprot.readListBegin()
18667 
          for _i371 in xrange(_size367):
18668 
            _elem372 = Item()
18669 
            _elem372.read(iprot)
18670 
            self.success.append(_elem372)
6531 vikram.rag 18671 
          iprot.readListEnd()
18672 
        else:
18673 
          iprot.skip(ftype)
18674 
      else:
18675 
        iprot.skip(ftype)
18676 
      iprot.readFieldEnd()
18677 
    iprot.readStructEnd()
18678 
 
18679 
  def write(self, oprot):
18680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18682 
      return
18683 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18684 
    if self.success is not None:
18685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18687 
      for iter373 in self.success:
18688 
        iter373.write(oprot)
6531 vikram.rag 18689 
      oprot.writeListEnd()
18690 
      oprot.writeFieldEnd()
18691 
    oprot.writeFieldStop()
18692 
    oprot.writeStructEnd()
18693 
 
18694 
  def validate(self):
18695 
    return
18696 
 
18697 
 
18698 
  def __repr__(self):
18699 
    L = ['%s=%r' % (key, value)
18700 
      for key, value in self.__dict__.iteritems()]
18701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18702 
 
18703 
  def __eq__(self, other):
18704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18705 
 
18706 
  def __ne__(self, other):
18707 
    return not (self == other)
6805 anupam.sin 18708 
 
6821 amar.kumar 18709 
class getAllAliveItems_args:
18710 
 
18711 
  thrift_spec = (
18712 
  )
18713 
 
18714 
  def read(self, iprot):
18715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18717 
      return
18718 
    iprot.readStructBegin()
18719 
    while True:
18720 
      (fname, ftype, fid) = iprot.readFieldBegin()
18721 
      if ftype == TType.STOP:
18722 
        break
18723 
      else:
18724 
        iprot.skip(ftype)
18725 
      iprot.readFieldEnd()
18726 
    iprot.readStructEnd()
18727 
 
18728 
  def write(self, oprot):
18729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18731 
      return
18732 
    oprot.writeStructBegin('getAllAliveItems_args')
18733 
    oprot.writeFieldStop()
18734 
    oprot.writeStructEnd()
18735 
 
18736 
  def validate(self):
18737 
    return
18738 
 
18739 
 
18740 
  def __repr__(self):
18741 
    L = ['%s=%r' % (key, value)
18742 
      for key, value in self.__dict__.iteritems()]
18743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18744 
 
18745 
  def __eq__(self, other):
18746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18747 
 
18748 
  def __ne__(self, other):
18749 
    return not (self == other)
18750 
 
18751 
class getAllAliveItems_result:
18752 
  """
18753 
  Attributes:
18754 
   - success
18755 
  """
18756 
 
18757 
  thrift_spec = (
18758 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18759 
  )
18760 
 
18761 
  def __init__(self, success=None,):
18762 
    self.success = success
18763 
 
18764 
  def read(self, iprot):
18765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18767 
      return
18768 
    iprot.readStructBegin()
18769 
    while True:
18770 
      (fname, ftype, fid) = iprot.readFieldBegin()
18771 
      if ftype == TType.STOP:
18772 
        break
18773 
      if fid == 0:
18774 
        if ftype == TType.LIST:
18775 
          self.success = []
9155 kshitij.so 18776 
          (_etype377, _size374) = iprot.readListBegin()
18777 
          for _i378 in xrange(_size374):
18778 
            _elem379 = Item()
18779 
            _elem379.read(iprot)
18780 
            self.success.append(_elem379)
6821 amar.kumar 18781 
          iprot.readListEnd()
18782 
        else:
18783 
          iprot.skip(ftype)
18784 
      else:
18785 
        iprot.skip(ftype)
18786 
      iprot.readFieldEnd()
18787 
    iprot.readStructEnd()
18788 
 
18789 
  def write(self, oprot):
18790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18792 
      return
18793 
    oprot.writeStructBegin('getAllAliveItems_result')
18794 
    if self.success is not None:
18795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18797 
      for iter380 in self.success:
18798 
        iter380.write(oprot)
6821 amar.kumar 18799 
      oprot.writeListEnd()
18800 
      oprot.writeFieldEnd()
18801 
    oprot.writeFieldStop()
18802 
    oprot.writeStructEnd()
18803 
 
18804 
  def validate(self):
18805 
    return
18806 
 
18807 
 
18808 
  def __repr__(self):
18809 
    L = ['%s=%r' % (key, value)
18810 
      for key, value in self.__dict__.iteritems()]
18811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18812 
 
18813 
  def __eq__(self, other):
18814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18815 
 
18816 
  def __ne__(self, other):
18817 
    return not (self == other)
18818 
 
6805 anupam.sin 18819 
class getInsuranceAmount_args:
18820 
  """
18821 
  Attributes:
18822 
   - itemId
6921 anupam.sin 18823 
   - price
6805 anupam.sin 18824 
   - insurerId
18825 
   - quantity
18826 
  """
18827 
 
18828 
  thrift_spec = (
18829 
    None, # 0
18830 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18831 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18832 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18833 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18834 
  )
18835 
 
6921 anupam.sin 18836 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18837 
    self.itemId = itemId
6921 anupam.sin 18838 
    self.price = price
6805 anupam.sin 18839 
    self.insurerId = insurerId
18840 
    self.quantity = quantity
18841 
 
18842 
  def read(self, iprot):
18843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18845 
      return
18846 
    iprot.readStructBegin()
18847 
    while True:
18848 
      (fname, ftype, fid) = iprot.readFieldBegin()
18849 
      if ftype == TType.STOP:
18850 
        break
18851 
      if fid == 1:
18852 
        if ftype == TType.I64:
18853 
          self.itemId = iprot.readI64();
18854 
        else:
18855 
          iprot.skip(ftype)
18856 
      elif fid == 2:
6921 anupam.sin 18857 
        if ftype == TType.DOUBLE:
18858 
          self.price = iprot.readDouble();
18859 
        else:
18860 
          iprot.skip(ftype)
18861 
      elif fid == 3:
6805 anupam.sin 18862 
        if ftype == TType.I64:
18863 
          self.insurerId = iprot.readI64();
18864 
        else:
18865 
          iprot.skip(ftype)
6921 anupam.sin 18866 
      elif fid == 4:
6805 anupam.sin 18867 
        if ftype == TType.I64:
18868 
          self.quantity = iprot.readI64();
18869 
        else:
18870 
          iprot.skip(ftype)
18871 
      else:
18872 
        iprot.skip(ftype)
18873 
      iprot.readFieldEnd()
18874 
    iprot.readStructEnd()
18875 
 
18876 
  def write(self, oprot):
18877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18879 
      return
18880 
    oprot.writeStructBegin('getInsuranceAmount_args')
18881 
    if self.itemId is not None:
18882 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18883 
      oprot.writeI64(self.itemId)
18884 
      oprot.writeFieldEnd()
6921 anupam.sin 18885 
    if self.price is not None:
18886 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18887 
      oprot.writeDouble(self.price)
18888 
      oprot.writeFieldEnd()
6805 anupam.sin 18889 
    if self.insurerId is not None:
6921 anupam.sin 18890 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18891 
      oprot.writeI64(self.insurerId)
18892 
      oprot.writeFieldEnd()
18893 
    if self.quantity is not None:
6921 anupam.sin 18894 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18895 
      oprot.writeI64(self.quantity)
18896 
      oprot.writeFieldEnd()
18897 
    oprot.writeFieldStop()
18898 
    oprot.writeStructEnd()
18899 
 
18900 
  def validate(self):
18901 
    return
18902 
 
18903 
 
18904 
  def __repr__(self):
18905 
    L = ['%s=%r' % (key, value)
18906 
      for key, value in self.__dict__.iteritems()]
18907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18908 
 
18909 
  def __eq__(self, other):
18910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18911 
 
18912 
  def __ne__(self, other):
18913 
    return not (self == other)
18914 
 
18915 
class getInsuranceAmount_result:
18916 
  """
18917 
  Attributes:
18918 
   - success
18919 
  """
18920 
 
18921 
  thrift_spec = (
18922 
    (0, TType.I64, 'success', None, None, ), # 0
18923 
  )
18924 
 
18925 
  def __init__(self, success=None,):
18926 
    self.success = success
18927 
 
18928 
  def read(self, iprot):
18929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18931 
      return
18932 
    iprot.readStructBegin()
18933 
    while True:
18934 
      (fname, ftype, fid) = iprot.readFieldBegin()
18935 
      if ftype == TType.STOP:
18936 
        break
18937 
      if fid == 0:
18938 
        if ftype == TType.I64:
18939 
          self.success = iprot.readI64();
18940 
        else:
18941 
          iprot.skip(ftype)
18942 
      else:
18943 
        iprot.skip(ftype)
18944 
      iprot.readFieldEnd()
18945 
    iprot.readStructEnd()
18946 
 
18947 
  def write(self, oprot):
18948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18950 
      return
18951 
    oprot.writeStructBegin('getInsuranceAmount_result')
18952 
    if self.success is not None:
18953 
      oprot.writeFieldBegin('success', TType.I64, 0)
18954 
      oprot.writeI64(self.success)
18955 
      oprot.writeFieldEnd()
18956 
    oprot.writeFieldStop()
18957 
    oprot.writeStructEnd()
18958 
 
18959 
  def validate(self):
18960 
    return
18961 
 
18962 
 
18963 
  def __repr__(self):
18964 
    L = ['%s=%r' % (key, value)
18965 
      for key, value in self.__dict__.iteritems()]
18966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18967 
 
18968 
  def __eq__(self, other):
18969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18970 
 
18971 
  def __ne__(self, other):
18972 
    return not (self == other)
18973 
 
18974 
class getInsurer_args:
18975 
  """
18976 
  Attributes:
18977 
   - insurerId
18978 
  """
18979 
 
18980 
  thrift_spec = (
18981 
    None, # 0
18982 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18983 
  )
18984 
 
18985 
  def __init__(self, insurerId=None,):
18986 
    self.insurerId = insurerId
18987 
 
18988 
  def read(self, iprot):
18989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18991 
      return
18992 
    iprot.readStructBegin()
18993 
    while True:
18994 
      (fname, ftype, fid) = iprot.readFieldBegin()
18995 
      if ftype == TType.STOP:
18996 
        break
18997 
      if fid == 1:
18998 
        if ftype == TType.I64:
18999 
          self.insurerId = iprot.readI64();
19000 
        else:
19001 
          iprot.skip(ftype)
19002 
      else:
19003 
        iprot.skip(ftype)
19004 
      iprot.readFieldEnd()
19005 
    iprot.readStructEnd()
19006 
 
19007 
  def write(self, oprot):
19008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19010 
      return
19011 
    oprot.writeStructBegin('getInsurer_args')
19012 
    if self.insurerId is not None:
19013 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19014 
      oprot.writeI64(self.insurerId)
19015 
      oprot.writeFieldEnd()
19016 
    oprot.writeFieldStop()
19017 
    oprot.writeStructEnd()
19018 
 
19019 
  def validate(self):
19020 
    return
19021 
 
19022 
 
19023 
  def __repr__(self):
19024 
    L = ['%s=%r' % (key, value)
19025 
      for key, value in self.__dict__.iteritems()]
19026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19027 
 
19028 
  def __eq__(self, other):
19029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19030 
 
19031 
  def __ne__(self, other):
19032 
    return not (self == other)
19033 
 
19034 
class getInsurer_result:
19035 
  """
19036 
  Attributes:
19037 
   - success
19038 
  """
19039 
 
19040 
  thrift_spec = (
19041 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19042 
  )
19043 
 
19044 
  def __init__(self, success=None,):
19045 
    self.success = success
19046 
 
19047 
  def read(self, iprot):
19048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19050 
      return
19051 
    iprot.readStructBegin()
19052 
    while True:
19053 
      (fname, ftype, fid) = iprot.readFieldBegin()
19054 
      if ftype == TType.STOP:
19055 
        break
19056 
      if fid == 0:
19057 
        if ftype == TType.STRUCT:
19058 
          self.success = Insurer()
19059 
          self.success.read(iprot)
19060 
        else:
19061 
          iprot.skip(ftype)
19062 
      else:
19063 
        iprot.skip(ftype)
19064 
      iprot.readFieldEnd()
19065 
    iprot.readStructEnd()
19066 
 
19067 
  def write(self, oprot):
19068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19070 
      return
19071 
    oprot.writeStructBegin('getInsurer_result')
19072 
    if self.success is not None:
19073 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19074 
      self.success.write(oprot)
19075 
      oprot.writeFieldEnd()
19076 
    oprot.writeFieldStop()
19077 
    oprot.writeStructEnd()
19078 
 
19079 
  def validate(self):
19080 
    return
19081 
 
19082 
 
19083 
  def __repr__(self):
19084 
    L = ['%s=%r' % (key, value)
19085 
      for key, value in self.__dict__.iteritems()]
19086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19087 
 
19088 
  def __eq__(self, other):
19089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19090 
 
19091 
  def __ne__(self, other):
19092 
    return not (self == other)
6838 vikram.rag 19093 
 
19094 
class getAllInsurers_args:
19095 
 
19096 
  thrift_spec = (
19097 
  )
19098 
 
19099 
  def read(self, iprot):
19100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19102 
      return
19103 
    iprot.readStructBegin()
19104 
    while True:
19105 
      (fname, ftype, fid) = iprot.readFieldBegin()
19106 
      if ftype == TType.STOP:
19107 
        break
19108 
      else:
19109 
        iprot.skip(ftype)
19110 
      iprot.readFieldEnd()
19111 
    iprot.readStructEnd()
19112 
 
19113 
  def write(self, oprot):
19114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19116 
      return
19117 
    oprot.writeStructBegin('getAllInsurers_args')
19118 
    oprot.writeFieldStop()
19119 
    oprot.writeStructEnd()
19120 
 
19121 
  def validate(self):
19122 
    return
19123 
 
19124 
 
19125 
  def __repr__(self):
19126 
    L = ['%s=%r' % (key, value)
19127 
      for key, value in self.__dict__.iteritems()]
19128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19129 
 
19130 
  def __eq__(self, other):
19131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19132 
 
19133 
  def __ne__(self, other):
19134 
    return not (self == other)
19135 
 
19136 
class getAllInsurers_result:
19137 
  """
19138 
  Attributes:
19139 
   - success
19140 
  """
19141 
 
19142 
  thrift_spec = (
19143 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19144 
  )
19145 
 
19146 
  def __init__(self, success=None,):
19147 
    self.success = success
19148 
 
19149 
  def read(self, iprot):
19150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19152 
      return
19153 
    iprot.readStructBegin()
19154 
    while True:
19155 
      (fname, ftype, fid) = iprot.readFieldBegin()
19156 
      if ftype == TType.STOP:
19157 
        break
19158 
      if fid == 0:
19159 
        if ftype == TType.LIST:
19160 
          self.success = []
9155 kshitij.so 19161 
          (_etype384, _size381) = iprot.readListBegin()
19162 
          for _i385 in xrange(_size381):
19163 
            _elem386 = Insurer()
19164 
            _elem386.read(iprot)
19165 
            self.success.append(_elem386)
6838 vikram.rag 19166 
          iprot.readListEnd()
19167 
        else:
19168 
          iprot.skip(ftype)
19169 
      else:
19170 
        iprot.skip(ftype)
19171 
      iprot.readFieldEnd()
19172 
    iprot.readStructEnd()
19173 
 
19174 
  def write(self, oprot):
19175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19177 
      return
19178 
    oprot.writeStructBegin('getAllInsurers_result')
19179 
    if self.success is not None:
19180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19182 
      for iter387 in self.success:
19183 
        iter387.write(oprot)
6838 vikram.rag 19184 
      oprot.writeListEnd()
19185 
      oprot.writeFieldEnd()
19186 
    oprot.writeFieldStop()
19187 
    oprot.writeStructEnd()
19188 
 
19189 
  def validate(self):
19190 
    return
19191 
 
19192 
 
19193 
  def __repr__(self):
19194 
    L = ['%s=%r' % (key, value)
19195 
      for key, value in self.__dict__.iteritems()]
19196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19197 
 
19198 
  def __eq__(self, other):
19199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19200 
 
19201 
  def __ne__(self, other):
19202 
    return not (self == other)
6962 rajveer 19203 
 
19204 
class updateInsuranceDeclaredAmount_args:
19205 
  """
19206 
  Attributes:
19207 
   - insurerId
19208 
   - amount
19209 
  """
19210 
 
19211 
  thrift_spec = (
19212 
    None, # 0
19213 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19214 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19215 
  )
19216 
 
19217 
  def __init__(self, insurerId=None, amount=None,):
19218 
    self.insurerId = insurerId
19219 
    self.amount = amount
19220 
 
19221 
  def read(self, iprot):
19222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19224 
      return
19225 
    iprot.readStructBegin()
19226 
    while True:
19227 
      (fname, ftype, fid) = iprot.readFieldBegin()
19228 
      if ftype == TType.STOP:
19229 
        break
19230 
      if fid == 1:
19231 
        if ftype == TType.I64:
19232 
          self.insurerId = iprot.readI64();
19233 
        else:
19234 
          iprot.skip(ftype)
19235 
      elif fid == 2:
19236 
        if ftype == TType.DOUBLE:
19237 
          self.amount = iprot.readDouble();
19238 
        else:
19239 
          iprot.skip(ftype)
19240 
      else:
19241 
        iprot.skip(ftype)
19242 
      iprot.readFieldEnd()
19243 
    iprot.readStructEnd()
19244 
 
19245 
  def write(self, oprot):
19246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19248 
      return
19249 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19250 
    if self.insurerId is not None:
19251 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19252 
      oprot.writeI64(self.insurerId)
19253 
      oprot.writeFieldEnd()
19254 
    if self.amount is not None:
19255 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19256 
      oprot.writeDouble(self.amount)
19257 
      oprot.writeFieldEnd()
19258 
    oprot.writeFieldStop()
19259 
    oprot.writeStructEnd()
19260 
 
19261 
  def validate(self):
19262 
    return
19263 
 
19264 
 
19265 
  def __repr__(self):
19266 
    L = ['%s=%r' % (key, value)
19267 
      for key, value in self.__dict__.iteritems()]
19268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19269 
 
19270 
  def __eq__(self, other):
19271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19272 
 
19273 
  def __ne__(self, other):
19274 
    return not (self == other)
19275 
 
19276 
class updateInsuranceDeclaredAmount_result:
19277 
 
19278 
  thrift_spec = (
19279 
  )
19280 
 
19281 
  def read(self, iprot):
19282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19284 
      return
19285 
    iprot.readStructBegin()
19286 
    while True:
19287 
      (fname, ftype, fid) = iprot.readFieldBegin()
19288 
      if ftype == TType.STOP:
19289 
        break
19290 
      else:
19291 
        iprot.skip(ftype)
19292 
      iprot.readFieldEnd()
19293 
    iprot.readStructEnd()
19294 
 
19295 
  def write(self, oprot):
19296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19298 
      return
19299 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19300 
    oprot.writeFieldStop()
19301 
    oprot.writeStructEnd()
19302 
 
19303 
  def validate(self):
19304 
    return
19305 
 
19306 
 
19307 
  def __repr__(self):
19308 
    L = ['%s=%r' % (key, value)
19309 
      for key, value in self.__dict__.iteritems()]
19310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19311 
 
19312 
  def __eq__(self, other):
19313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19314 
 
19315 
  def __ne__(self, other):
19316 
    return not (self == other)
7190 amar.kumar 19317 
 
19318 
class getFreebieForItem_args:
19319 
  """
19320 
  Attributes:
19321 
   - itemId
19322 
  """
19323 
 
19324 
  thrift_spec = (
19325 
    None, # 0
19326 
    (1, TType.I64, 'itemId', None, None, ), # 1
19327 
  )
19328 
 
19329 
  def __init__(self, itemId=None,):
19330 
    self.itemId = itemId
19331 
 
19332 
  def read(self, iprot):
19333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19335 
      return
19336 
    iprot.readStructBegin()
19337 
    while True:
19338 
      (fname, ftype, fid) = iprot.readFieldBegin()
19339 
      if ftype == TType.STOP:
19340 
        break
19341 
      if fid == 1:
19342 
        if ftype == TType.I64:
19343 
          self.itemId = iprot.readI64();
19344 
        else:
19345 
          iprot.skip(ftype)
19346 
      else:
19347 
        iprot.skip(ftype)
19348 
      iprot.readFieldEnd()
19349 
    iprot.readStructEnd()
19350 
 
19351 
  def write(self, oprot):
19352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19354 
      return
19355 
    oprot.writeStructBegin('getFreebieForItem_args')
19356 
    if self.itemId is not None:
19357 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19358 
      oprot.writeI64(self.itemId)
19359 
      oprot.writeFieldEnd()
19360 
    oprot.writeFieldStop()
19361 
    oprot.writeStructEnd()
19362 
 
19363 
  def validate(self):
19364 
    return
19365 
 
19366 
 
19367 
  def __repr__(self):
19368 
    L = ['%s=%r' % (key, value)
19369 
      for key, value in self.__dict__.iteritems()]
19370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19371 
 
19372 
  def __eq__(self, other):
19373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19374 
 
19375 
  def __ne__(self, other):
19376 
    return not (self == other)
19377 
 
19378 
class getFreebieForItem_result:
19379 
  """
19380 
  Attributes:
19381 
   - success
19382 
  """
19383 
 
19384 
  thrift_spec = (
19385 
    (0, TType.I64, 'success', None, None, ), # 0
19386 
  )
19387 
 
19388 
  def __init__(self, success=None,):
19389 
    self.success = success
19390 
 
19391 
  def read(self, iprot):
19392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19394 
      return
19395 
    iprot.readStructBegin()
19396 
    while True:
19397 
      (fname, ftype, fid) = iprot.readFieldBegin()
19398 
      if ftype == TType.STOP:
19399 
        break
19400 
      if fid == 0:
19401 
        if ftype == TType.I64:
19402 
          self.success = iprot.readI64();
19403 
        else:
19404 
          iprot.skip(ftype)
19405 
      else:
19406 
        iprot.skip(ftype)
19407 
      iprot.readFieldEnd()
19408 
    iprot.readStructEnd()
19409 
 
19410 
  def write(self, oprot):
19411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19413 
      return
19414 
    oprot.writeStructBegin('getFreebieForItem_result')
19415 
    if self.success is not None:
19416 
      oprot.writeFieldBegin('success', TType.I64, 0)
19417 
      oprot.writeI64(self.success)
19418 
      oprot.writeFieldEnd()
19419 
    oprot.writeFieldStop()
19420 
    oprot.writeStructEnd()
19421 
 
19422 
  def validate(self):
19423 
    return
19424 
 
19425 
 
19426 
  def __repr__(self):
19427 
    L = ['%s=%r' % (key, value)
19428 
      for key, value in self.__dict__.iteritems()]
19429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19430 
 
19431 
  def __eq__(self, other):
19432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19433 
 
19434 
  def __ne__(self, other):
19435 
    return not (self == other)
19436 
 
19437 
class addOrUpdateFreebieForItem_args:
19438 
  """
19439 
  Attributes:
19440 
   - freebieItem
19441 
  """
19442 
 
19443 
  thrift_spec = (
19444 
    None, # 0
19445 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19446 
  )
19447 
 
19448 
  def __init__(self, freebieItem=None,):
19449 
    self.freebieItem = freebieItem
19450 
 
19451 
  def read(self, iprot):
19452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19454 
      return
19455 
    iprot.readStructBegin()
19456 
    while True:
19457 
      (fname, ftype, fid) = iprot.readFieldBegin()
19458 
      if ftype == TType.STOP:
19459 
        break
19460 
      if fid == 1:
19461 
        if ftype == TType.STRUCT:
19462 
          self.freebieItem = FreebieItem()
19463 
          self.freebieItem.read(iprot)
19464 
        else:
19465 
          iprot.skip(ftype)
19466 
      else:
19467 
        iprot.skip(ftype)
19468 
      iprot.readFieldEnd()
19469 
    iprot.readStructEnd()
19470 
 
19471 
  def write(self, oprot):
19472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19474 
      return
19475 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19476 
    if self.freebieItem is not None:
19477 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19478 
      self.freebieItem.write(oprot)
19479 
      oprot.writeFieldEnd()
19480 
    oprot.writeFieldStop()
19481 
    oprot.writeStructEnd()
19482 
 
19483 
  def validate(self):
19484 
    return
19485 
 
19486 
 
19487 
  def __repr__(self):
19488 
    L = ['%s=%r' % (key, value)
19489 
      for key, value in self.__dict__.iteritems()]
19490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19491 
 
19492 
  def __eq__(self, other):
19493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19494 
 
19495 
  def __ne__(self, other):
19496 
    return not (self == other)
19497 
 
19498 
class addOrUpdateFreebieForItem_result:
19499 
 
19500 
  thrift_spec = (
19501 
  )
19502 
 
19503 
  def read(self, iprot):
19504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19506 
      return
19507 
    iprot.readStructBegin()
19508 
    while True:
19509 
      (fname, ftype, fid) = iprot.readFieldBegin()
19510 
      if ftype == TType.STOP:
19511 
        break
19512 
      else:
19513 
        iprot.skip(ftype)
19514 
      iprot.readFieldEnd()
19515 
    iprot.readStructEnd()
19516 
 
19517 
  def write(self, oprot):
19518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19520 
      return
19521 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19522 
    oprot.writeFieldStop()
19523 
    oprot.writeStructEnd()
19524 
 
19525 
  def validate(self):
19526 
    return
19527 
 
19528 
 
19529 
  def __repr__(self):
19530 
    L = ['%s=%r' % (key, value)
19531 
      for key, value in self.__dict__.iteritems()]
19532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19533 
 
19534 
  def __eq__(self, other):
19535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19536 
 
19537 
  def __ne__(self, other):
19538 
    return not (self == other)
7256 rajveer 19539 
 
7272 amit.gupta 19540 
class addOrUpdateBrandInfo_args:
19541 
  """
19542 
  Attributes:
19543 
   - brandInfo
19544 
  """
19545 
 
19546 
  thrift_spec = (
19547 
    None, # 0
19548 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19549 
  )
19550 
 
19551 
  def __init__(self, brandInfo=None,):
19552 
    self.brandInfo = brandInfo
19553 
 
19554 
  def read(self, iprot):
19555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19557 
      return
19558 
    iprot.readStructBegin()
19559 
    while True:
19560 
      (fname, ftype, fid) = iprot.readFieldBegin()
19561 
      if ftype == TType.STOP:
19562 
        break
19563 
      if fid == 1:
19564 
        if ftype == TType.STRUCT:
19565 
          self.brandInfo = BrandInfo()
19566 
          self.brandInfo.read(iprot)
19567 
        else:
19568 
          iprot.skip(ftype)
19569 
      else:
19570 
        iprot.skip(ftype)
19571 
      iprot.readFieldEnd()
19572 
    iprot.readStructEnd()
19573 
 
19574 
  def write(self, oprot):
19575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19577 
      return
19578 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19579 
    if self.brandInfo is not None:
19580 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19581 
      self.brandInfo.write(oprot)
19582 
      oprot.writeFieldEnd()
19583 
    oprot.writeFieldStop()
19584 
    oprot.writeStructEnd()
19585 
 
19586 
  def validate(self):
19587 
    return
19588 
 
19589 
 
19590 
  def __repr__(self):
19591 
    L = ['%s=%r' % (key, value)
19592 
      for key, value in self.__dict__.iteritems()]
19593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19594 
 
19595 
  def __eq__(self, other):
19596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19597 
 
19598 
  def __ne__(self, other):
19599 
    return not (self == other)
19600 
 
19601 
class addOrUpdateBrandInfo_result:
19602 
 
19603 
  thrift_spec = (
19604 
  )
19605 
 
19606 
  def read(self, iprot):
19607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19609 
      return
19610 
    iprot.readStructBegin()
19611 
    while True:
19612 
      (fname, ftype, fid) = iprot.readFieldBegin()
19613 
      if ftype == TType.STOP:
19614 
        break
19615 
      else:
19616 
        iprot.skip(ftype)
19617 
      iprot.readFieldEnd()
19618 
    iprot.readStructEnd()
19619 
 
19620 
  def write(self, oprot):
19621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19623 
      return
19624 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19625 
    oprot.writeFieldStop()
19626 
    oprot.writeStructEnd()
19627 
 
19628 
  def validate(self):
19629 
    return
19630 
 
19631 
 
19632 
  def __repr__(self):
19633 
    L = ['%s=%r' % (key, value)
19634 
      for key, value in self.__dict__.iteritems()]
19635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19636 
 
19637 
  def __eq__(self, other):
19638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19639 
 
19640 
  def __ne__(self, other):
19641 
    return not (self == other)
19642 
 
19643 
class getBrandInfo_args:
19644 
 
19645 
  thrift_spec = (
19646 
  )
19647 
 
19648 
  def read(self, iprot):
19649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19651 
      return
19652 
    iprot.readStructBegin()
19653 
    while True:
19654 
      (fname, ftype, fid) = iprot.readFieldBegin()
19655 
      if ftype == TType.STOP:
19656 
        break
19657 
      else:
19658 
        iprot.skip(ftype)
19659 
      iprot.readFieldEnd()
19660 
    iprot.readStructEnd()
19661 
 
19662 
  def write(self, oprot):
19663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19665 
      return
19666 
    oprot.writeStructBegin('getBrandInfo_args')
19667 
    oprot.writeFieldStop()
19668 
    oprot.writeStructEnd()
19669 
 
19670 
  def validate(self):
19671 
    return
19672 
 
19673 
 
19674 
  def __repr__(self):
19675 
    L = ['%s=%r' % (key, value)
19676 
      for key, value in self.__dict__.iteritems()]
19677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19678 
 
19679 
  def __eq__(self, other):
19680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19681 
 
19682 
  def __ne__(self, other):
19683 
    return not (self == other)
19684 
 
19685 
class getBrandInfo_result:
19686 
  """
19687 
  Attributes:
19688 
   - success
19689 
  """
19690 
 
19691 
  thrift_spec = (
19692 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19693 
  )
19694 
 
19695 
  def __init__(self, success=None,):
19696 
    self.success = success
19697 
 
19698 
  def read(self, iprot):
19699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19701 
      return
19702 
    iprot.readStructBegin()
19703 
    while True:
19704 
      (fname, ftype, fid) = iprot.readFieldBegin()
19705 
      if ftype == TType.STOP:
19706 
        break
19707 
      if fid == 0:
19708 
        if ftype == TType.MAP:
19709 
          self.success = {}
9155 kshitij.so 19710 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19711 
          for _i392 in xrange(_size388):
19712 
            _key393 = iprot.readString();
19713 
            _val394 = BrandInfo()
19714 
            _val394.read(iprot)
19715 
            self.success[_key393] = _val394
7272 amit.gupta 19716 
          iprot.readMapEnd()
19717 
        else:
19718 
          iprot.skip(ftype)
19719 
      else:
19720 
        iprot.skip(ftype)
19721 
      iprot.readFieldEnd()
19722 
    iprot.readStructEnd()
19723 
 
19724 
  def write(self, oprot):
19725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19727 
      return
19728 
    oprot.writeStructBegin('getBrandInfo_result')
19729 
    if self.success is not None:
19730 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19731 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19732 
      for kiter395,viter396 in self.success.items():
19733 
        oprot.writeString(kiter395)
19734 
        viter396.write(oprot)
7272 amit.gupta 19735 
      oprot.writeMapEnd()
19736 
      oprot.writeFieldEnd()
19737 
    oprot.writeFieldStop()
19738 
    oprot.writeStructEnd()
19739 
 
19740 
  def validate(self):
19741 
    return
19742 
 
19743 
 
19744 
  def __repr__(self):
19745 
    L = ['%s=%r' % (key, value)
19746 
      for key, value in self.__dict__.iteritems()]
19747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19748 
 
19749 
  def __eq__(self, other):
19750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19751 
 
19752 
  def __ne__(self, other):
19753 
    return not (self == other)
19754 
 
7256 rajveer 19755 
class getStorePricing_args:
19756 
  """
19757 
  Attributes:
19758 
   - itemId
19759 
  """
19760 
 
19761 
  thrift_spec = (
19762 
    None, # 0
19763 
    (1, TType.I64, 'itemId', None, None, ), # 1
19764 
  )
19765 
 
19766 
  def __init__(self, itemId=None,):
19767 
    self.itemId = itemId
19768 
 
19769 
  def read(self, iprot):
19770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19772 
      return
19773 
    iprot.readStructBegin()
19774 
    while True:
19775 
      (fname, ftype, fid) = iprot.readFieldBegin()
19776 
      if ftype == TType.STOP:
19777 
        break
19778 
      if fid == 1:
19779 
        if ftype == TType.I64:
19780 
          self.itemId = iprot.readI64();
19781 
        else:
19782 
          iprot.skip(ftype)
19783 
      else:
19784 
        iprot.skip(ftype)
19785 
      iprot.readFieldEnd()
19786 
    iprot.readStructEnd()
19787 
 
19788 
  def write(self, oprot):
19789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19791 
      return
19792 
    oprot.writeStructBegin('getStorePricing_args')
19793 
    if self.itemId is not None:
19794 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19795 
      oprot.writeI64(self.itemId)
19796 
      oprot.writeFieldEnd()
19797 
    oprot.writeFieldStop()
19798 
    oprot.writeStructEnd()
19799 
 
19800 
  def validate(self):
19801 
    return
19802 
 
19803 
 
19804 
  def __repr__(self):
19805 
    L = ['%s=%r' % (key, value)
19806 
      for key, value in self.__dict__.iteritems()]
19807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19808 
 
19809 
  def __eq__(self, other):
19810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19811 
 
19812 
  def __ne__(self, other):
19813 
    return not (self == other)
19814 
 
19815 
class getStorePricing_result:
19816 
  """
19817 
  Attributes:
19818 
   - success
19819 
  """
19820 
 
19821 
  thrift_spec = (
19822 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19823 
  )
19824 
 
19825 
  def __init__(self, success=None,):
19826 
    self.success = success
19827 
 
19828 
  def read(self, iprot):
19829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19831 
      return
19832 
    iprot.readStructBegin()
19833 
    while True:
19834 
      (fname, ftype, fid) = iprot.readFieldBegin()
19835 
      if ftype == TType.STOP:
19836 
        break
19837 
      if fid == 0:
19838 
        if ftype == TType.STRUCT:
19839 
          self.success = StorePricing()
19840 
          self.success.read(iprot)
19841 
        else:
19842 
          iprot.skip(ftype)
19843 
      else:
19844 
        iprot.skip(ftype)
19845 
      iprot.readFieldEnd()
19846 
    iprot.readStructEnd()
19847 
 
19848 
  def write(self, oprot):
19849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19851 
      return
19852 
    oprot.writeStructBegin('getStorePricing_result')
19853 
    if self.success is not None:
19854 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19855 
      self.success.write(oprot)
19856 
      oprot.writeFieldEnd()
19857 
    oprot.writeFieldStop()
19858 
    oprot.writeStructEnd()
19859 
 
19860 
  def validate(self):
19861 
    return
19862 
 
19863 
 
19864 
  def __repr__(self):
19865 
    L = ['%s=%r' % (key, value)
19866 
      for key, value in self.__dict__.iteritems()]
19867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19868 
 
19869 
  def __eq__(self, other):
19870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19871 
 
19872 
  def __ne__(self, other):
19873 
    return not (self == other)
7265 rajveer 19874 
 
7306 rajveer 19875 
class getStorePricings_args:
19876 
  """
19877 
  Attributes:
19878 
   - itemIds
19879 
  """
19880 
 
19881 
  thrift_spec = (
19882 
    None, # 0
19883 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19884 
  )
19885 
 
19886 
  def __init__(self, itemIds=None,):
19887 
    self.itemIds = itemIds
19888 
 
19889 
  def read(self, iprot):
19890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19892 
      return
19893 
    iprot.readStructBegin()
19894 
    while True:
19895 
      (fname, ftype, fid) = iprot.readFieldBegin()
19896 
      if ftype == TType.STOP:
19897 
        break
19898 
      if fid == 1:
19899 
        if ftype == TType.LIST:
19900 
          self.itemIds = []
9155 kshitij.so 19901 
          (_etype400, _size397) = iprot.readListBegin()
19902 
          for _i401 in xrange(_size397):
19903 
            _elem402 = iprot.readI64();
19904 
            self.itemIds.append(_elem402)
7306 rajveer 19905 
          iprot.readListEnd()
19906 
        else:
19907 
          iprot.skip(ftype)
19908 
      else:
19909 
        iprot.skip(ftype)
19910 
      iprot.readFieldEnd()
19911 
    iprot.readStructEnd()
19912 
 
19913 
  def write(self, oprot):
19914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19916 
      return
19917 
    oprot.writeStructBegin('getStorePricings_args')
19918 
    if self.itemIds is not None:
19919 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19920 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19921 
      for iter403 in self.itemIds:
19922 
        oprot.writeI64(iter403)
7306 rajveer 19923 
      oprot.writeListEnd()
19924 
      oprot.writeFieldEnd()
19925 
    oprot.writeFieldStop()
19926 
    oprot.writeStructEnd()
19927 
 
19928 
  def validate(self):
19929 
    return
19930 
 
19931 
 
19932 
  def __repr__(self):
19933 
    L = ['%s=%r' % (key, value)
19934 
      for key, value in self.__dict__.iteritems()]
19935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19936 
 
19937 
  def __eq__(self, other):
19938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19939 
 
19940 
  def __ne__(self, other):
19941 
    return not (self == other)
19942 
 
19943 
class getStorePricings_result:
19944 
  """
19945 
  Attributes:
19946 
   - success
19947 
  """
19948 
 
19949 
  thrift_spec = (
19950 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19951 
  )
19952 
 
19953 
  def __init__(self, success=None,):
19954 
    self.success = success
19955 
 
19956 
  def read(self, iprot):
19957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19959 
      return
19960 
    iprot.readStructBegin()
19961 
    while True:
19962 
      (fname, ftype, fid) = iprot.readFieldBegin()
19963 
      if ftype == TType.STOP:
19964 
        break
19965 
      if fid == 0:
19966 
        if ftype == TType.LIST:
19967 
          self.success = []
9155 kshitij.so 19968 
          (_etype407, _size404) = iprot.readListBegin()
19969 
          for _i408 in xrange(_size404):
19970 
            _elem409 = StorePricing()
19971 
            _elem409.read(iprot)
19972 
            self.success.append(_elem409)
7306 rajveer 19973 
          iprot.readListEnd()
19974 
        else:
19975 
          iprot.skip(ftype)
19976 
      else:
19977 
        iprot.skip(ftype)
19978 
      iprot.readFieldEnd()
19979 
    iprot.readStructEnd()
19980 
 
19981 
  def write(self, oprot):
19982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19984 
      return
19985 
    oprot.writeStructBegin('getStorePricings_result')
19986 
    if self.success is not None:
19987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19989 
      for iter410 in self.success:
19990 
        iter410.write(oprot)
7306 rajveer 19991 
      oprot.writeListEnd()
19992 
      oprot.writeFieldEnd()
19993 
    oprot.writeFieldStop()
19994 
    oprot.writeStructEnd()
19995 
 
19996 
  def validate(self):
19997 
    return
19998 
 
19999 
 
20000 
  def __repr__(self):
20001 
    L = ['%s=%r' % (key, value)
20002 
      for key, value in self.__dict__.iteritems()]
20003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20004 
 
20005 
  def __eq__(self, other):
20006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20007 
 
20008 
  def __ne__(self, other):
20009 
    return not (self == other)
20010 
 
7265 rajveer 20011 
class updateStorePricing_args:
20012 
  """
20013 
  Attributes:
20014 
   - sp
7382 rajveer 20015 
   - allColors
7265 rajveer 20016 
  """
20017 
 
20018 
  thrift_spec = (
20019 
    None, # 0
20020 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20021 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20022 
  )
20023 
 
7382 rajveer 20024 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20025 
    self.sp = sp
7382 rajveer 20026 
    self.allColors = allColors
7265 rajveer 20027 
 
20028 
  def read(self, iprot):
20029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20031 
      return
20032 
    iprot.readStructBegin()
20033 
    while True:
20034 
      (fname, ftype, fid) = iprot.readFieldBegin()
20035 
      if ftype == TType.STOP:
20036 
        break
20037 
      if fid == 1:
20038 
        if ftype == TType.STRUCT:
20039 
          self.sp = StorePricing()
20040 
          self.sp.read(iprot)
20041 
        else:
20042 
          iprot.skip(ftype)
7382 rajveer 20043 
      elif fid == 2:
20044 
        if ftype == TType.BOOL:
20045 
          self.allColors = iprot.readBool();
20046 
        else:
20047 
          iprot.skip(ftype)
7265 rajveer 20048 
      else:
20049 
        iprot.skip(ftype)
20050 
      iprot.readFieldEnd()
20051 
    iprot.readStructEnd()
20052 
 
20053 
  def write(self, oprot):
20054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20056 
      return
20057 
    oprot.writeStructBegin('updateStorePricing_args')
20058 
    if self.sp is not None:
20059 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20060 
      self.sp.write(oprot)
20061 
      oprot.writeFieldEnd()
7382 rajveer 20062 
    if self.allColors is not None:
20063 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20064 
      oprot.writeBool(self.allColors)
20065 
      oprot.writeFieldEnd()
7265 rajveer 20066 
    oprot.writeFieldStop()
20067 
    oprot.writeStructEnd()
20068 
 
20069 
  def validate(self):
20070 
    return
20071 
 
20072 
 
20073 
  def __repr__(self):
20074 
    L = ['%s=%r' % (key, value)
20075 
      for key, value in self.__dict__.iteritems()]
20076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20077 
 
20078 
  def __eq__(self, other):
20079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20080 
 
20081 
  def __ne__(self, other):
20082 
    return not (self == other)
20083 
 
20084 
class updateStorePricing_result:
20085 
 
20086 
  thrift_spec = (
20087 
  )
20088 
 
20089 
  def read(self, iprot):
20090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20092 
      return
20093 
    iprot.readStructBegin()
20094 
    while True:
20095 
      (fname, ftype, fid) = iprot.readFieldBegin()
20096 
      if ftype == TType.STOP:
20097 
        break
20098 
      else:
20099 
        iprot.skip(ftype)
20100 
      iprot.readFieldEnd()
20101 
    iprot.readStructEnd()
20102 
 
20103 
  def write(self, oprot):
20104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20106 
      return
20107 
    oprot.writeStructBegin('updateStorePricing_result')
20108 
    oprot.writeFieldStop()
20109 
    oprot.writeStructEnd()
20110 
 
20111 
  def validate(self):
20112 
    return
20113 
 
20114 
 
20115 
  def __repr__(self):
20116 
    L = ['%s=%r' % (key, value)
20117 
      for key, value in self.__dict__.iteritems()]
20118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20119 
 
20120 
  def __eq__(self, other):
20121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20122 
 
20123 
  def __ne__(self, other):
20124 
    return not (self == other)
7281 kshitij.so 20125 
 
20126 
class getAllAmazonListedItems_args:
20127 
 
20128 
  thrift_spec = (
20129 
  )
20130 
 
20131 
  def read(self, iprot):
20132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20134 
      return
20135 
    iprot.readStructBegin()
20136 
    while True:
20137 
      (fname, ftype, fid) = iprot.readFieldBegin()
20138 
      if ftype == TType.STOP:
20139 
        break
20140 
      else:
20141 
        iprot.skip(ftype)
20142 
      iprot.readFieldEnd()
20143 
    iprot.readStructEnd()
20144 
 
20145 
  def write(self, oprot):
20146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20148 
      return
20149 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20150 
    oprot.writeFieldStop()
20151 
    oprot.writeStructEnd()
20152 
 
20153 
  def validate(self):
20154 
    return
20155 
 
20156 
 
20157 
  def __repr__(self):
20158 
    L = ['%s=%r' % (key, value)
20159 
      for key, value in self.__dict__.iteritems()]
20160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20161 
 
20162 
  def __eq__(self, other):
20163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20164 
 
20165 
  def __ne__(self, other):
20166 
    return not (self == other)
20167 
 
20168 
class getAllAmazonListedItems_result:
20169 
  """
20170 
  Attributes:
20171 
   - success
20172 
  """
20173 
 
20174 
  thrift_spec = (
20175 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20176 
  )
20177 
 
20178 
  def __init__(self, success=None,):
20179 
    self.success = success
20180 
 
20181 
  def read(self, iprot):
20182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20184 
      return
20185 
    iprot.readStructBegin()
20186 
    while True:
20187 
      (fname, ftype, fid) = iprot.readFieldBegin()
20188 
      if ftype == TType.STOP:
20189 
        break
20190 
      if fid == 0:
20191 
        if ftype == TType.LIST:
20192 
          self.success = []
9155 kshitij.so 20193 
          (_etype414, _size411) = iprot.readListBegin()
20194 
          for _i415 in xrange(_size411):
20195 
            _elem416 = Amazonlisted()
20196 
            _elem416.read(iprot)
20197 
            self.success.append(_elem416)
7281 kshitij.so 20198 
          iprot.readListEnd()
20199 
        else:
20200 
          iprot.skip(ftype)
20201 
      else:
20202 
        iprot.skip(ftype)
20203 
      iprot.readFieldEnd()
20204 
    iprot.readStructEnd()
20205 
 
20206 
  def write(self, oprot):
20207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20209 
      return
20210 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20211 
    if self.success is not None:
20212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20213 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20214 
      for iter417 in self.success:
20215 
        iter417.write(oprot)
7281 kshitij.so 20216 
      oprot.writeListEnd()
20217 
      oprot.writeFieldEnd()
20218 
    oprot.writeFieldStop()
20219 
    oprot.writeStructEnd()
20220 
 
20221 
  def validate(self):
20222 
    return
20223 
 
20224 
 
20225 
  def __repr__(self):
20226 
    L = ['%s=%r' % (key, value)
20227 
      for key, value in self.__dict__.iteritems()]
20228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20229 
 
20230 
  def __eq__(self, other):
20231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20232 
 
20233 
  def __ne__(self, other):
20234 
    return not (self == other)
20235 
 
8619 kshitij.so 20236 
class searchAmazonItems_args:
20237 
  """
20238 
  Attributes:
20239 
   - searchTerm
20240 
   - offset
20241 
   - limit
20242 
  """
20243 
 
20244 
  thrift_spec = (
20245 
    None, # 0
20246 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20247 
    (2, TType.I64, 'offset', None, None, ), # 2
20248 
    (3, TType.I64, 'limit', None, None, ), # 3
20249 
  )
20250 
 
20251 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20252 
    self.searchTerm = searchTerm
20253 
    self.offset = offset
20254 
    self.limit = limit
20255 
 
20256 
  def read(self, iprot):
20257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20259 
      return
20260 
    iprot.readStructBegin()
20261 
    while True:
20262 
      (fname, ftype, fid) = iprot.readFieldBegin()
20263 
      if ftype == TType.STOP:
20264 
        break
20265 
      if fid == 1:
20266 
        if ftype == TType.LIST:
20267 
          self.searchTerm = []
9155 kshitij.so 20268 
          (_etype421, _size418) = iprot.readListBegin()
20269 
          for _i422 in xrange(_size418):
20270 
            _elem423 = iprot.readString();
20271 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20272 
          iprot.readListEnd()
20273 
        else:
20274 
          iprot.skip(ftype)
20275 
      elif fid == 2:
20276 
        if ftype == TType.I64:
20277 
          self.offset = iprot.readI64();
20278 
        else:
20279 
          iprot.skip(ftype)
20280 
      elif fid == 3:
20281 
        if ftype == TType.I64:
20282 
          self.limit = iprot.readI64();
20283 
        else:
20284 
          iprot.skip(ftype)
20285 
      else:
20286 
        iprot.skip(ftype)
20287 
      iprot.readFieldEnd()
20288 
    iprot.readStructEnd()
20289 
 
20290 
  def write(self, oprot):
20291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20293 
      return
20294 
    oprot.writeStructBegin('searchAmazonItems_args')
20295 
    if self.searchTerm is not None:
20296 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20297 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20298 
      for iter424 in self.searchTerm:
20299 
        oprot.writeString(iter424)
8619 kshitij.so 20300 
      oprot.writeListEnd()
20301 
      oprot.writeFieldEnd()
20302 
    if self.offset is not None:
20303 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20304 
      oprot.writeI64(self.offset)
20305 
      oprot.writeFieldEnd()
20306 
    if self.limit is not None:
20307 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20308 
      oprot.writeI64(self.limit)
20309 
      oprot.writeFieldEnd()
20310 
    oprot.writeFieldStop()
20311 
    oprot.writeStructEnd()
20312 
 
20313 
  def validate(self):
20314 
    return
20315 
 
20316 
 
20317 
  def __repr__(self):
20318 
    L = ['%s=%r' % (key, value)
20319 
      for key, value in self.__dict__.iteritems()]
20320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20321 
 
20322 
  def __eq__(self, other):
20323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20324 
 
20325 
  def __ne__(self, other):
20326 
    return not (self == other)
20327 
 
20328 
class searchAmazonItems_result:
20329 
  """
20330 
  Attributes:
20331 
   - success
20332 
  """
20333 
 
20334 
  thrift_spec = (
20335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20336 
  )
20337 
 
20338 
  def __init__(self, success=None,):
20339 
    self.success = success
20340 
 
20341 
  def read(self, iprot):
20342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20344 
      return
20345 
    iprot.readStructBegin()
20346 
    while True:
20347 
      (fname, ftype, fid) = iprot.readFieldBegin()
20348 
      if ftype == TType.STOP:
20349 
        break
20350 
      if fid == 0:
20351 
        if ftype == TType.LIST:
20352 
          self.success = []
9155 kshitij.so 20353 
          (_etype428, _size425) = iprot.readListBegin()
20354 
          for _i429 in xrange(_size425):
20355 
            _elem430 = Amazonlisted()
20356 
            _elem430.read(iprot)
20357 
            self.success.append(_elem430)
8619 kshitij.so 20358 
          iprot.readListEnd()
20359 
        else:
20360 
          iprot.skip(ftype)
20361 
      else:
20362 
        iprot.skip(ftype)
20363 
      iprot.readFieldEnd()
20364 
    iprot.readStructEnd()
20365 
 
20366 
  def write(self, oprot):
20367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20369 
      return
20370 
    oprot.writeStructBegin('searchAmazonItems_result')
20371 
    if self.success is not None:
20372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20374 
      for iter431 in self.success:
20375 
        iter431.write(oprot)
8619 kshitij.so 20376 
      oprot.writeListEnd()
20377 
      oprot.writeFieldEnd()
20378 
    oprot.writeFieldStop()
20379 
    oprot.writeStructEnd()
20380 
 
20381 
  def validate(self):
20382 
    return
20383 
 
20384 
 
20385 
  def __repr__(self):
20386 
    L = ['%s=%r' % (key, value)
20387 
      for key, value in self.__dict__.iteritems()]
20388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20389 
 
20390 
  def __eq__(self, other):
20391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20392 
 
20393 
  def __ne__(self, other):
20394 
    return not (self == other)
20395 
 
20396 
class getAmazonSearchResultCount_args:
20397 
  """
20398 
  Attributes:
20399 
   - searchTerm
20400 
  """
20401 
 
20402 
  thrift_spec = (
20403 
    None, # 0
20404 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20405 
  )
20406 
 
20407 
  def __init__(self, searchTerm=None,):
20408 
    self.searchTerm = searchTerm
20409 
 
20410 
  def read(self, iprot):
20411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20413 
      return
20414 
    iprot.readStructBegin()
20415 
    while True:
20416 
      (fname, ftype, fid) = iprot.readFieldBegin()
20417 
      if ftype == TType.STOP:
20418 
        break
20419 
      if fid == 1:
20420 
        if ftype == TType.LIST:
20421 
          self.searchTerm = []
9155 kshitij.so 20422 
          (_etype435, _size432) = iprot.readListBegin()
20423 
          for _i436 in xrange(_size432):
20424 
            _elem437 = iprot.readString();
20425 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20426 
          iprot.readListEnd()
20427 
        else:
20428 
          iprot.skip(ftype)
20429 
      else:
20430 
        iprot.skip(ftype)
20431 
      iprot.readFieldEnd()
20432 
    iprot.readStructEnd()
20433 
 
20434 
  def write(self, oprot):
20435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20437 
      return
20438 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20439 
    if self.searchTerm is not None:
20440 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20441 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20442 
      for iter438 in self.searchTerm:
20443 
        oprot.writeString(iter438)
8619 kshitij.so 20444 
      oprot.writeListEnd()
20445 
      oprot.writeFieldEnd()
20446 
    oprot.writeFieldStop()
20447 
    oprot.writeStructEnd()
20448 
 
20449 
  def validate(self):
20450 
    return
20451 
 
20452 
 
20453 
  def __repr__(self):
20454 
    L = ['%s=%r' % (key, value)
20455 
      for key, value in self.__dict__.iteritems()]
20456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20457 
 
20458 
  def __eq__(self, other):
20459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20460 
 
20461 
  def __ne__(self, other):
20462 
    return not (self == other)
20463 
 
20464 
class getAmazonSearchResultCount_result:
20465 
  """
20466 
  Attributes:
20467 
   - success
20468 
  """
20469 
 
20470 
  thrift_spec = (
20471 
    (0, TType.I64, 'success', None, None, ), # 0
20472 
  )
20473 
 
20474 
  def __init__(self, success=None,):
20475 
    self.success = success
20476 
 
20477 
  def read(self, iprot):
20478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20480 
      return
20481 
    iprot.readStructBegin()
20482 
    while True:
20483 
      (fname, ftype, fid) = iprot.readFieldBegin()
20484 
      if ftype == TType.STOP:
20485 
        break
20486 
      if fid == 0:
20487 
        if ftype == TType.I64:
20488 
          self.success = iprot.readI64();
20489 
        else:
20490 
          iprot.skip(ftype)
20491 
      else:
20492 
        iprot.skip(ftype)
20493 
      iprot.readFieldEnd()
20494 
    iprot.readStructEnd()
20495 
 
20496 
  def write(self, oprot):
20497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20499 
      return
20500 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20501 
    if self.success is not None:
20502 
      oprot.writeFieldBegin('success', TType.I64, 0)
20503 
      oprot.writeI64(self.success)
20504 
      oprot.writeFieldEnd()
20505 
    oprot.writeFieldStop()
20506 
    oprot.writeStructEnd()
20507 
 
20508 
  def validate(self):
20509 
    return
20510 
 
20511 
 
20512 
  def __repr__(self):
20513 
    L = ['%s=%r' % (key, value)
20514 
      for key, value in self.__dict__.iteritems()]
20515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20516 
 
20517 
  def __eq__(self, other):
20518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20519 
 
20520 
  def __ne__(self, other):
20521 
    return not (self == other)
20522 
 
20523 
class getCountForAmazonlistedItems_args:
20524 
 
20525 
  thrift_spec = (
20526 
  )
20527 
 
20528 
  def read(self, iprot):
20529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20531 
      return
20532 
    iprot.readStructBegin()
20533 
    while True:
20534 
      (fname, ftype, fid) = iprot.readFieldBegin()
20535 
      if ftype == TType.STOP:
20536 
        break
20537 
      else:
20538 
        iprot.skip(ftype)
20539 
      iprot.readFieldEnd()
20540 
    iprot.readStructEnd()
20541 
 
20542 
  def write(self, oprot):
20543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20545 
      return
20546 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20547 
    oprot.writeFieldStop()
20548 
    oprot.writeStructEnd()
20549 
 
20550 
  def validate(self):
20551 
    return
20552 
 
20553 
 
20554 
  def __repr__(self):
20555 
    L = ['%s=%r' % (key, value)
20556 
      for key, value in self.__dict__.iteritems()]
20557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20558 
 
20559 
  def __eq__(self, other):
20560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20561 
 
20562 
  def __ne__(self, other):
20563 
    return not (self == other)
20564 
 
20565 
class getCountForAmazonlistedItems_result:
20566 
  """
20567 
  Attributes:
20568 
   - success
20569 
  """
20570 
 
20571 
  thrift_spec = (
20572 
    (0, TType.I64, 'success', None, None, ), # 0
20573 
  )
20574 
 
20575 
  def __init__(self, success=None,):
20576 
    self.success = success
20577 
 
20578 
  def read(self, iprot):
20579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20581 
      return
20582 
    iprot.readStructBegin()
20583 
    while True:
20584 
      (fname, ftype, fid) = iprot.readFieldBegin()
20585 
      if ftype == TType.STOP:
20586 
        break
20587 
      if fid == 0:
20588 
        if ftype == TType.I64:
20589 
          self.success = iprot.readI64();
20590 
        else:
20591 
          iprot.skip(ftype)
20592 
      else:
20593 
        iprot.skip(ftype)
20594 
      iprot.readFieldEnd()
20595 
    iprot.readStructEnd()
20596 
 
20597 
  def write(self, oprot):
20598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20600 
      return
20601 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20602 
    if self.success is not None:
20603 
      oprot.writeFieldBegin('success', TType.I64, 0)
20604 
      oprot.writeI64(self.success)
20605 
      oprot.writeFieldEnd()
20606 
    oprot.writeFieldStop()
20607 
    oprot.writeStructEnd()
20608 
 
20609 
  def validate(self):
20610 
    return
20611 
 
20612 
 
20613 
  def __repr__(self):
20614 
    L = ['%s=%r' % (key, value)
20615 
      for key, value in self.__dict__.iteritems()]
20616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20617 
 
20618 
  def __eq__(self, other):
20619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20620 
 
20621 
  def __ne__(self, other):
20622 
    return not (self == other)
20623 
 
7281 kshitij.so 20624 
class getAmazonItemDetails_args:
20625 
  """
20626 
  Attributes:
20627 
   - itemId
20628 
  """
20629 
 
20630 
  thrift_spec = (
20631 
    None, # 0
20632 
    (1, TType.I64, 'itemId', None, None, ), # 1
20633 
  )
20634 
 
20635 
  def __init__(self, itemId=None,):
20636 
    self.itemId = itemId
20637 
 
20638 
  def read(self, iprot):
20639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20641 
      return
20642 
    iprot.readStructBegin()
20643 
    while True:
20644 
      (fname, ftype, fid) = iprot.readFieldBegin()
20645 
      if ftype == TType.STOP:
20646 
        break
20647 
      if fid == 1:
20648 
        if ftype == TType.I64:
20649 
          self.itemId = iprot.readI64();
20650 
        else:
20651 
          iprot.skip(ftype)
20652 
      else:
20653 
        iprot.skip(ftype)
20654 
      iprot.readFieldEnd()
20655 
    iprot.readStructEnd()
20656 
 
20657 
  def write(self, oprot):
20658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20660 
      return
20661 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20662 
    if self.itemId is not None:
20663 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20664 
      oprot.writeI64(self.itemId)
20665 
      oprot.writeFieldEnd()
20666 
    oprot.writeFieldStop()
20667 
    oprot.writeStructEnd()
20668 
 
20669 
  def validate(self):
20670 
    return
20671 
 
20672 
 
20673 
  def __repr__(self):
20674 
    L = ['%s=%r' % (key, value)
20675 
      for key, value in self.__dict__.iteritems()]
20676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20677 
 
20678 
  def __eq__(self, other):
20679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20680 
 
20681 
  def __ne__(self, other):
20682 
    return not (self == other)
20683 
 
20684 
class getAmazonItemDetails_result:
20685 
  """
20686 
  Attributes:
20687 
   - success
20688 
  """
20689 
 
20690 
  thrift_spec = (
20691 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20692 
  )
20693 
 
20694 
  def __init__(self, success=None,):
20695 
    self.success = success
20696 
 
20697 
  def read(self, iprot):
20698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20700 
      return
20701 
    iprot.readStructBegin()
20702 
    while True:
20703 
      (fname, ftype, fid) = iprot.readFieldBegin()
20704 
      if ftype == TType.STOP:
20705 
        break
20706 
      if fid == 0:
20707 
        if ftype == TType.STRUCT:
20708 
          self.success = Amazonlisted()
20709 
          self.success.read(iprot)
20710 
        else:
20711 
          iprot.skip(ftype)
20712 
      else:
20713 
        iprot.skip(ftype)
20714 
      iprot.readFieldEnd()
20715 
    iprot.readStructEnd()
20716 
 
20717 
  def write(self, oprot):
20718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20720 
      return
20721 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20722 
    if self.success is not None:
20723 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20724 
      self.success.write(oprot)
20725 
      oprot.writeFieldEnd()
20726 
    oprot.writeFieldStop()
20727 
    oprot.writeStructEnd()
20728 
 
20729 
  def validate(self):
20730 
    return
20731 
 
20732 
 
20733 
  def __repr__(self):
20734 
    L = ['%s=%r' % (key, value)
20735 
      for key, value in self.__dict__.iteritems()]
20736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20737 
 
20738 
  def __eq__(self, other):
20739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20740 
 
20741 
  def __ne__(self, other):
20742 
    return not (self == other)
20743 
 
20744 
class updateAmazonItemDetails_args:
20745 
  """
20746 
  Attributes:
8168 kshitij.so 20747 
   - amazonlisted
7281 kshitij.so 20748 
  """
20749 
 
20750 
  thrift_spec = (
20751 
    None, # 0
8168 kshitij.so 20752 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20753 
  )
20754 
 
8168 kshitij.so 20755 
  def __init__(self, amazonlisted=None,):
20756 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20757 
 
20758 
  def read(self, iprot):
20759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20761 
      return
20762 
    iprot.readStructBegin()
20763 
    while True:
20764 
      (fname, ftype, fid) = iprot.readFieldBegin()
20765 
      if ftype == TType.STOP:
20766 
        break
20767 
      if fid == 1:
8168 kshitij.so 20768 
        if ftype == TType.STRUCT:
20769 
          self.amazonlisted = Amazonlisted()
20770 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20771 
        else:
20772 
          iprot.skip(ftype)
20773 
      else:
20774 
        iprot.skip(ftype)
20775 
      iprot.readFieldEnd()
20776 
    iprot.readStructEnd()
20777 
 
20778 
  def write(self, oprot):
20779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20781 
      return
20782 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20783 
    if self.amazonlisted is not None:
20784 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20785 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20786 
      oprot.writeFieldEnd()
20787 
    oprot.writeFieldStop()
20788 
    oprot.writeStructEnd()
20789 
 
20790 
  def validate(self):
20791 
    return
20792 
 
20793 
 
20794 
  def __repr__(self):
20795 
    L = ['%s=%r' % (key, value)
20796 
      for key, value in self.__dict__.iteritems()]
20797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20798 
 
20799 
  def __eq__(self, other):
20800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20801 
 
20802 
  def __ne__(self, other):
20803 
    return not (self == other)
20804 
 
20805 
class updateAmazonItemDetails_result:
20806 
 
20807 
  thrift_spec = (
20808 
  )
20809 
 
20810 
  def read(self, iprot):
20811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20813 
      return
20814 
    iprot.readStructBegin()
20815 
    while True:
20816 
      (fname, ftype, fid) = iprot.readFieldBegin()
20817 
      if ftype == TType.STOP:
20818 
        break
20819 
      else:
20820 
        iprot.skip(ftype)
20821 
      iprot.readFieldEnd()
20822 
    iprot.readStructEnd()
20823 
 
20824 
  def write(self, oprot):
20825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20827 
      return
20828 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20829 
    oprot.writeFieldStop()
20830 
    oprot.writeStructEnd()
20831 
 
20832 
  def validate(self):
20833 
    return
20834 
 
20835 
 
20836 
  def __repr__(self):
20837 
    L = ['%s=%r' % (key, value)
20838 
      for key, value in self.__dict__.iteritems()]
20839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20840 
 
20841 
  def __eq__(self, other):
20842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20843 
 
20844 
  def __ne__(self, other):
20845 
    return not (self == other)
20846 
 
20847 
class addAmazonItem_args:
20848 
  """
20849 
  Attributes:
20850 
   - amazonlisted
20851 
  """
20852 
 
20853 
  thrift_spec = (
20854 
    None, # 0
20855 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20856 
  )
20857 
 
20858 
  def __init__(self, amazonlisted=None,):
20859 
    self.amazonlisted = amazonlisted
20860 
 
20861 
  def read(self, iprot):
20862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20864 
      return
20865 
    iprot.readStructBegin()
20866 
    while True:
20867 
      (fname, ftype, fid) = iprot.readFieldBegin()
20868 
      if ftype == TType.STOP:
20869 
        break
20870 
      if fid == 1:
20871 
        if ftype == TType.STRUCT:
20872 
          self.amazonlisted = Amazonlisted()
20873 
          self.amazonlisted.read(iprot)
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      else:
20877 
        iprot.skip(ftype)
20878 
      iprot.readFieldEnd()
20879 
    iprot.readStructEnd()
20880 
 
20881 
  def write(self, oprot):
20882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20884 
      return
20885 
    oprot.writeStructBegin('addAmazonItem_args')
20886 
    if self.amazonlisted is not None:
20887 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20888 
      self.amazonlisted.write(oprot)
20889 
      oprot.writeFieldEnd()
20890 
    oprot.writeFieldStop()
20891 
    oprot.writeStructEnd()
20892 
 
20893 
  def validate(self):
20894 
    return
20895 
 
20896 
 
20897 
  def __repr__(self):
20898 
    L = ['%s=%r' % (key, value)
20899 
      for key, value in self.__dict__.iteritems()]
20900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20901 
 
20902 
  def __eq__(self, other):
20903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20904 
 
20905 
  def __ne__(self, other):
20906 
    return not (self == other)
20907 
 
20908 
class addAmazonItem_result:
20909 
 
20910 
  thrift_spec = (
20911 
  )
20912 
 
20913 
  def read(self, iprot):
20914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20916 
      return
20917 
    iprot.readStructBegin()
20918 
    while True:
20919 
      (fname, ftype, fid) = iprot.readFieldBegin()
20920 
      if ftype == TType.STOP:
20921 
        break
20922 
      else:
20923 
        iprot.skip(ftype)
20924 
      iprot.readFieldEnd()
20925 
    iprot.readStructEnd()
20926 
 
20927 
  def write(self, oprot):
20928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20930 
      return
20931 
    oprot.writeStructBegin('addAmazonItem_result')
20932 
    oprot.writeFieldStop()
20933 
    oprot.writeStructEnd()
20934 
 
20935 
  def validate(self):
20936 
    return
20937 
 
20938 
 
20939 
  def __repr__(self):
20940 
    L = ['%s=%r' % (key, value)
20941 
      for key, value in self.__dict__.iteritems()]
20942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20943 
 
20944 
  def __eq__(self, other):
20945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20946 
 
20947 
  def __ne__(self, other):
20948 
    return not (self == other)
7291 vikram.rag 20949 
 
20950 
class getAsinItems_args:
20951 
 
20952 
  thrift_spec = (
20953 
  )
20954 
 
20955 
  def read(self, iprot):
20956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20958 
      return
20959 
    iprot.readStructBegin()
20960 
    while True:
20961 
      (fname, ftype, fid) = iprot.readFieldBegin()
20962 
      if ftype == TType.STOP:
20963 
        break
20964 
      else:
20965 
        iprot.skip(ftype)
20966 
      iprot.readFieldEnd()
20967 
    iprot.readStructEnd()
20968 
 
20969 
  def write(self, oprot):
20970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20972 
      return
20973 
    oprot.writeStructBegin('getAsinItems_args')
20974 
    oprot.writeFieldStop()
20975 
    oprot.writeStructEnd()
20976 
 
20977 
  def validate(self):
20978 
    return
20979 
 
20980 
 
20981 
  def __repr__(self):
20982 
    L = ['%s=%r' % (key, value)
20983 
      for key, value in self.__dict__.iteritems()]
20984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20985 
 
20986 
  def __eq__(self, other):
20987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20988 
 
20989 
  def __ne__(self, other):
20990 
    return not (self == other)
20991 
 
20992 
class getAsinItems_result:
20993 
  """
20994 
  Attributes:
20995 
   - success
20996 
  """
20997 
 
20998 
  thrift_spec = (
20999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21000 
  )
21001 
 
21002 
  def __init__(self, success=None,):
21003 
    self.success = success
21004 
 
21005 
  def read(self, iprot):
21006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21008 
      return
21009 
    iprot.readStructBegin()
21010 
    while True:
21011 
      (fname, ftype, fid) = iprot.readFieldBegin()
21012 
      if ftype == TType.STOP:
21013 
        break
21014 
      if fid == 0:
21015 
        if ftype == TType.LIST:
21016 
          self.success = []
9155 kshitij.so 21017 
          (_etype442, _size439) = iprot.readListBegin()
21018 
          for _i443 in xrange(_size439):
21019 
            _elem444 = Item()
21020 
            _elem444.read(iprot)
21021 
            self.success.append(_elem444)
7291 vikram.rag 21022 
          iprot.readListEnd()
21023 
        else:
21024 
          iprot.skip(ftype)
21025 
      else:
21026 
        iprot.skip(ftype)
21027 
      iprot.readFieldEnd()
21028 
    iprot.readStructEnd()
21029 
 
21030 
  def write(self, oprot):
21031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21033 
      return
21034 
    oprot.writeStructBegin('getAsinItems_result')
21035 
    if self.success is not None:
21036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21037 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21038 
      for iter445 in self.success:
21039 
        iter445.write(oprot)
7291 vikram.rag 21040 
      oprot.writeListEnd()
21041 
      oprot.writeFieldEnd()
21042 
    oprot.writeFieldStop()
21043 
    oprot.writeStructEnd()
21044 
 
21045 
  def validate(self):
21046 
    return
21047 
 
21048 
 
21049 
  def __repr__(self):
21050 
    L = ['%s=%r' % (key, value)
21051 
      for key, value in self.__dict__.iteritems()]
21052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21053 
 
21054 
  def __eq__(self, other):
21055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21056 
 
21057 
  def __ne__(self, other):
21058 
    return not (self == other)
21059 
 
21060 
class getAllFbaListedItems_args:
21061 
 
21062 
  thrift_spec = (
21063 
  )
21064 
 
21065 
  def read(self, iprot):
21066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21068 
      return
21069 
    iprot.readStructBegin()
21070 
    while True:
21071 
      (fname, ftype, fid) = iprot.readFieldBegin()
21072 
      if ftype == TType.STOP:
21073 
        break
21074 
      else:
21075 
        iprot.skip(ftype)
21076 
      iprot.readFieldEnd()
21077 
    iprot.readStructEnd()
21078 
 
21079 
  def write(self, oprot):
21080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21082 
      return
21083 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21084 
    oprot.writeFieldStop()
21085 
    oprot.writeStructEnd()
21086 
 
21087 
  def validate(self):
21088 
    return
21089 
 
21090 
 
21091 
  def __repr__(self):
21092 
    L = ['%s=%r' % (key, value)
21093 
      for key, value in self.__dict__.iteritems()]
21094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21095 
 
21096 
  def __eq__(self, other):
21097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21098 
 
21099 
  def __ne__(self, other):
21100 
    return not (self == other)
21101 
 
21102 
class getAllFbaListedItems_result:
21103 
  """
21104 
  Attributes:
21105 
   - success
21106 
  """
21107 
 
21108 
  thrift_spec = (
21109 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21110 
  )
21111 
 
21112 
  def __init__(self, success=None,):
21113 
    self.success = success
21114 
 
21115 
  def read(self, iprot):
21116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21118 
      return
21119 
    iprot.readStructBegin()
21120 
    while True:
21121 
      (fname, ftype, fid) = iprot.readFieldBegin()
21122 
      if ftype == TType.STOP:
21123 
        break
21124 
      if fid == 0:
21125 
        if ftype == TType.LIST:
21126 
          self.success = []
9155 kshitij.so 21127 
          (_etype449, _size446) = iprot.readListBegin()
21128 
          for _i450 in xrange(_size446):
21129 
            _elem451 = Amazonlisted()
21130 
            _elem451.read(iprot)
21131 
            self.success.append(_elem451)
7291 vikram.rag 21132 
          iprot.readListEnd()
21133 
        else:
21134 
          iprot.skip(ftype)
21135 
      else:
21136 
        iprot.skip(ftype)
21137 
      iprot.readFieldEnd()
21138 
    iprot.readStructEnd()
21139 
 
21140 
  def write(self, oprot):
21141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21143 
      return
21144 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21145 
    if self.success is not None:
21146 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21147 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21148 
      for iter452 in self.success:
21149 
        iter452.write(oprot)
7291 vikram.rag 21150 
      oprot.writeListEnd()
21151 
      oprot.writeFieldEnd()
21152 
    oprot.writeFieldStop()
21153 
    oprot.writeStructEnd()
21154 
 
21155 
  def validate(self):
21156 
    return
21157 
 
21158 
 
21159 
  def __repr__(self):
21160 
    L = ['%s=%r' % (key, value)
21161 
      for key, value in self.__dict__.iteritems()]
21162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21163 
 
21164 
  def __eq__(self, other):
21165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21166 
 
21167 
  def __ne__(self, other):
21168 
    return not (self == other)
21169 
 
21170 
class getAllNonFbaListedItems_args:
21171 
 
21172 
  thrift_spec = (
21173 
  )
21174 
 
21175 
  def read(self, iprot):
21176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21178 
      return
21179 
    iprot.readStructBegin()
21180 
    while True:
21181 
      (fname, ftype, fid) = iprot.readFieldBegin()
21182 
      if ftype == TType.STOP:
21183 
        break
21184 
      else:
21185 
        iprot.skip(ftype)
21186 
      iprot.readFieldEnd()
21187 
    iprot.readStructEnd()
21188 
 
21189 
  def write(self, oprot):
21190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21192 
      return
21193 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21194 
    oprot.writeFieldStop()
21195 
    oprot.writeStructEnd()
21196 
 
21197 
  def validate(self):
21198 
    return
21199 
 
21200 
 
21201 
  def __repr__(self):
21202 
    L = ['%s=%r' % (key, value)
21203 
      for key, value in self.__dict__.iteritems()]
21204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21205 
 
21206 
  def __eq__(self, other):
21207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21208 
 
21209 
  def __ne__(self, other):
21210 
    return not (self == other)
21211 
 
21212 
class getAllNonFbaListedItems_result:
21213 
  """
21214 
  Attributes:
21215 
   - success
21216 
  """
21217 
 
21218 
  thrift_spec = (
21219 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21220 
  )
21221 
 
21222 
  def __init__(self, success=None,):
21223 
    self.success = success
21224 
 
21225 
  def read(self, iprot):
21226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21228 
      return
21229 
    iprot.readStructBegin()
21230 
    while True:
21231 
      (fname, ftype, fid) = iprot.readFieldBegin()
21232 
      if ftype == TType.STOP:
21233 
        break
21234 
      if fid == 0:
21235 
        if ftype == TType.LIST:
21236 
          self.success = []
9155 kshitij.so 21237 
          (_etype456, _size453) = iprot.readListBegin()
21238 
          for _i457 in xrange(_size453):
21239 
            _elem458 = Amazonlisted()
21240 
            _elem458.read(iprot)
21241 
            self.success.append(_elem458)
7291 vikram.rag 21242 
          iprot.readListEnd()
21243 
        else:
21244 
          iprot.skip(ftype)
21245 
      else:
21246 
        iprot.skip(ftype)
21247 
      iprot.readFieldEnd()
21248 
    iprot.readStructEnd()
21249 
 
21250 
  def write(self, oprot):
21251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21253 
      return
21254 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21255 
    if self.success is not None:
21256 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21257 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21258 
      for iter459 in self.success:
21259 
        iter459.write(oprot)
7291 vikram.rag 21260 
      oprot.writeListEnd()
21261 
      oprot.writeFieldEnd()
21262 
    oprot.writeFieldStop()
21263 
    oprot.writeStructEnd()
21264 
 
21265 
  def validate(self):
21266 
    return
21267 
 
21268 
 
21269 
  def __repr__(self):
21270 
    L = ['%s=%r' % (key, value)
21271 
      for key, value in self.__dict__.iteritems()]
21272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21273 
 
21274 
  def __eq__(self, other):
21275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21276 
 
21277 
  def __ne__(self, other):
21278 
    return not (self == other)
7460 kshitij.so 21279 
 
21280 
class updateItemInventory_args:
21281 
  """
21282 
  Attributes:
21283 
   - itemId
21284 
   - holdInventory
21285 
   - defaultInventory
21286 
  """
21287 
 
21288 
  thrift_spec = (
21289 
    None, # 0
21290 
    (1, TType.I64, 'itemId', None, None, ), # 1
21291 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21292 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21293 
  )
21294 
 
21295 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21296 
    self.itemId = itemId
21297 
    self.holdInventory = holdInventory
21298 
    self.defaultInventory = defaultInventory
21299 
 
21300 
  def read(self, iprot):
21301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21303 
      return
21304 
    iprot.readStructBegin()
21305 
    while True:
21306 
      (fname, ftype, fid) = iprot.readFieldBegin()
21307 
      if ftype == TType.STOP:
21308 
        break
21309 
      if fid == 1:
21310 
        if ftype == TType.I64:
21311 
          self.itemId = iprot.readI64();
21312 
        else:
21313 
          iprot.skip(ftype)
21314 
      elif fid == 2:
21315 
        if ftype == TType.I64:
21316 
          self.holdInventory = iprot.readI64();
21317 
        else:
21318 
          iprot.skip(ftype)
21319 
      elif fid == 3:
21320 
        if ftype == TType.I64:
21321 
          self.defaultInventory = iprot.readI64();
21322 
        else:
21323 
          iprot.skip(ftype)
21324 
      else:
21325 
        iprot.skip(ftype)
21326 
      iprot.readFieldEnd()
21327 
    iprot.readStructEnd()
21328 
 
21329 
  def write(self, oprot):
21330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21332 
      return
21333 
    oprot.writeStructBegin('updateItemInventory_args')
21334 
    if self.itemId is not None:
21335 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21336 
      oprot.writeI64(self.itemId)
21337 
      oprot.writeFieldEnd()
21338 
    if self.holdInventory is not None:
21339 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21340 
      oprot.writeI64(self.holdInventory)
21341 
      oprot.writeFieldEnd()
21342 
    if self.defaultInventory is not None:
21343 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21344 
      oprot.writeI64(self.defaultInventory)
21345 
      oprot.writeFieldEnd()
21346 
    oprot.writeFieldStop()
21347 
    oprot.writeStructEnd()
21348 
 
21349 
  def validate(self):
21350 
    return
21351 
 
21352 
 
21353 
  def __repr__(self):
21354 
    L = ['%s=%r' % (key, value)
21355 
      for key, value in self.__dict__.iteritems()]
21356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21357 
 
21358 
  def __eq__(self, other):
21359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21360 
 
21361 
  def __ne__(self, other):
21362 
    return not (self == other)
21363 
 
21364 
class updateItemInventory_result:
21365 
  """
21366 
  Attributes:
21367 
   - success
21368 
  """
21369 
 
21370 
  thrift_spec = (
21371 
    (0, TType.BOOL, 'success', None, None, ), # 0
21372 
  )
21373 
 
21374 
  def __init__(self, success=None,):
21375 
    self.success = success
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 0:
21387 
        if ftype == TType.BOOL:
21388 
          self.success = iprot.readBool();
21389 
        else:
21390 
          iprot.skip(ftype)
21391 
      else:
21392 
        iprot.skip(ftype)
21393 
      iprot.readFieldEnd()
21394 
    iprot.readStructEnd()
21395 
 
21396 
  def write(self, oprot):
21397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21399 
      return
21400 
    oprot.writeStructBegin('updateItemInventory_result')
21401 
    if self.success is not None:
21402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21403 
      oprot.writeBool(self.success)
21404 
      oprot.writeFieldEnd()
21405 
    oprot.writeFieldStop()
21406 
    oprot.writeStructEnd()
21407 
 
21408 
  def validate(self):
21409 
    return
21410 
 
21411 
 
21412 
  def __repr__(self):
21413 
    L = ['%s=%r' % (key, value)
21414 
      for key, value in self.__dict__.iteritems()]
21415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21416 
 
21417 
  def __eq__(self, other):
21418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21419 
 
21420 
  def __ne__(self, other):
21421 
    return not (self == other)
7770 kshitij.so 21422 
 
21423 
class updateTimestampForAmazonFeeds_args:
21424 
  """
21425 
  Attributes:
21426 
   - type
21427 
   - sku
21428 
   - timestamp
21429 
  """
21430 
 
21431 
  thrift_spec = (
21432 
    None, # 0
21433 
    (1, TType.STRING, 'type', None, None, ), # 1
21434 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21435 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21436 
  )
21437 
 
21438 
  def __init__(self, type=None, sku=None, timestamp=None,):
21439 
    self.type = type
21440 
    self.sku = sku
21441 
    self.timestamp = timestamp
21442 
 
21443 
  def read(self, iprot):
21444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21446 
      return
21447 
    iprot.readStructBegin()
21448 
    while True:
21449 
      (fname, ftype, fid) = iprot.readFieldBegin()
21450 
      if ftype == TType.STOP:
21451 
        break
21452 
      if fid == 1:
21453 
        if ftype == TType.STRING:
21454 
          self.type = iprot.readString();
21455 
        else:
21456 
          iprot.skip(ftype)
21457 
      elif fid == 2:
21458 
        if ftype == TType.LIST:
21459 
          self.sku = []
9155 kshitij.so 21460 
          (_etype463, _size460) = iprot.readListBegin()
21461 
          for _i464 in xrange(_size460):
21462 
            _elem465 = iprot.readI64();
21463 
            self.sku.append(_elem465)
7770 kshitij.so 21464 
          iprot.readListEnd()
21465 
        else:
21466 
          iprot.skip(ftype)
21467 
      elif fid == 3:
21468 
        if ftype == TType.I64:
21469 
          self.timestamp = iprot.readI64();
21470 
        else:
21471 
          iprot.skip(ftype)
21472 
      else:
21473 
        iprot.skip(ftype)
21474 
      iprot.readFieldEnd()
21475 
    iprot.readStructEnd()
21476 
 
21477 
  def write(self, oprot):
21478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21480 
      return
21481 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21482 
    if self.type is not None:
21483 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21484 
      oprot.writeString(self.type)
21485 
      oprot.writeFieldEnd()
21486 
    if self.sku is not None:
21487 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21488 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21489 
      for iter466 in self.sku:
21490 
        oprot.writeI64(iter466)
7770 kshitij.so 21491 
      oprot.writeListEnd()
21492 
      oprot.writeFieldEnd()
21493 
    if self.timestamp is not None:
21494 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21495 
      oprot.writeI64(self.timestamp)
21496 
      oprot.writeFieldEnd()
21497 
    oprot.writeFieldStop()
21498 
    oprot.writeStructEnd()
21499 
 
21500 
  def validate(self):
21501 
    return
21502 
 
21503 
 
21504 
  def __repr__(self):
21505 
    L = ['%s=%r' % (key, value)
21506 
      for key, value in self.__dict__.iteritems()]
21507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21508 
 
21509 
  def __eq__(self, other):
21510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21511 
 
21512 
  def __ne__(self, other):
21513 
    return not (self == other)
21514 
 
21515 
class updateTimestampForAmazonFeeds_result:
21516 
  """
21517 
  Attributes:
21518 
   - success
21519 
  """
21520 
 
21521 
  thrift_spec = (
21522 
    (0, TType.BOOL, 'success', None, None, ), # 0
21523 
  )
21524 
 
21525 
  def __init__(self, success=None,):
21526 
    self.success = success
21527 
 
21528 
  def read(self, iprot):
21529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21531 
      return
21532 
    iprot.readStructBegin()
21533 
    while True:
21534 
      (fname, ftype, fid) = iprot.readFieldBegin()
21535 
      if ftype == TType.STOP:
21536 
        break
21537 
      if fid == 0:
21538 
        if ftype == TType.BOOL:
21539 
          self.success = iprot.readBool();
21540 
        else:
21541 
          iprot.skip(ftype)
21542 
      else:
21543 
        iprot.skip(ftype)
21544 
      iprot.readFieldEnd()
21545 
    iprot.readStructEnd()
21546 
 
21547 
  def write(self, oprot):
21548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21550 
      return
21551 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21552 
    if self.success is not None:
21553 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21554 
      oprot.writeBool(self.success)
21555 
      oprot.writeFieldEnd()
21556 
    oprot.writeFieldStop()
21557 
    oprot.writeStructEnd()
21558 
 
21559 
  def validate(self):
21560 
    return
21561 
 
21562 
 
21563 
  def __repr__(self):
21564 
    L = ['%s=%r' % (key, value)
21565 
      for key, value in self.__dict__.iteritems()]
21566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21567 
 
21568 
  def __eq__(self, other):
21569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21570 
 
21571 
  def __ne__(self, other):
21572 
    return not (self == other)
7897 amar.kumar 21573 
 
21574 
class getAllParentCategories_args:
21575 
 
21576 
  thrift_spec = (
21577 
  )
21578 
 
21579 
  def read(self, iprot):
21580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21582 
      return
21583 
    iprot.readStructBegin()
21584 
    while True:
21585 
      (fname, ftype, fid) = iprot.readFieldBegin()
21586 
      if ftype == TType.STOP:
21587 
        break
21588 
      else:
21589 
        iprot.skip(ftype)
21590 
      iprot.readFieldEnd()
21591 
    iprot.readStructEnd()
21592 
 
21593 
  def write(self, oprot):
21594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21596 
      return
21597 
    oprot.writeStructBegin('getAllParentCategories_args')
21598 
    oprot.writeFieldStop()
21599 
    oprot.writeStructEnd()
21600 
 
21601 
  def validate(self):
21602 
    return
21603 
 
21604 
 
21605 
  def __repr__(self):
21606 
    L = ['%s=%r' % (key, value)
21607 
      for key, value in self.__dict__.iteritems()]
21608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21609 
 
21610 
  def __eq__(self, other):
21611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21612 
 
21613 
  def __ne__(self, other):
21614 
    return not (self == other)
21615 
 
21616 
class getAllParentCategories_result:
21617 
  """
21618 
  Attributes:
21619 
   - success
21620 
  """
21621 
 
21622 
  thrift_spec = (
21623 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21624 
  )
21625 
 
21626 
  def __init__(self, success=None,):
21627 
    self.success = success
21628 
 
21629 
  def read(self, iprot):
21630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21632 
      return
21633 
    iprot.readStructBegin()
21634 
    while True:
21635 
      (fname, ftype, fid) = iprot.readFieldBegin()
21636 
      if ftype == TType.STOP:
21637 
        break
21638 
      if fid == 0:
21639 
        if ftype == TType.LIST:
21640 
          self.success = []
9155 kshitij.so 21641 
          (_etype470, _size467) = iprot.readListBegin()
21642 
          for _i471 in xrange(_size467):
21643 
            _elem472 = Category()
21644 
            _elem472.read(iprot)
21645 
            self.success.append(_elem472)
7897 amar.kumar 21646 
          iprot.readListEnd()
21647 
        else:
21648 
          iprot.skip(ftype)
21649 
      else:
21650 
        iprot.skip(ftype)
21651 
      iprot.readFieldEnd()
21652 
    iprot.readStructEnd()
21653 
 
21654 
  def write(self, oprot):
21655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21657 
      return
21658 
    oprot.writeStructBegin('getAllParentCategories_result')
21659 
    if self.success is not None:
21660 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21661 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21662 
      for iter473 in self.success:
21663 
        iter473.write(oprot)
7897 amar.kumar 21664 
      oprot.writeListEnd()
21665 
      oprot.writeFieldEnd()
21666 
    oprot.writeFieldStop()
21667 
    oprot.writeStructEnd()
21668 
 
21669 
  def validate(self):
21670 
    return
21671 
 
21672 
 
21673 
  def __repr__(self):
21674 
    L = ['%s=%r' % (key, value)
21675 
      for key, value in self.__dict__.iteritems()]
21676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21677 
 
21678 
  def __eq__(self, other):
21679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21680 
 
21681 
  def __ne__(self, other):
21682 
    return not (self == other)
7977 kshitij.so 21683 
 
21684 
class addPageViewEvent_args:
21685 
  """
21686 
  Attributes:
21687 
   - pageViewEvents
21688 
  """
21689 
 
21690 
  thrift_spec = (
21691 
    None, # 0
21692 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21693 
  )
21694 
 
21695 
  def __init__(self, pageViewEvents=None,):
21696 
    self.pageViewEvents = pageViewEvents
21697 
 
21698 
  def read(self, iprot):
21699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21701 
      return
21702 
    iprot.readStructBegin()
21703 
    while True:
21704 
      (fname, ftype, fid) = iprot.readFieldBegin()
21705 
      if ftype == TType.STOP:
21706 
        break
21707 
      if fid == 1:
21708 
        if ftype == TType.STRUCT:
21709 
          self.pageViewEvents = PageViewEvents()
21710 
          self.pageViewEvents.read(iprot)
21711 
        else:
21712 
          iprot.skip(ftype)
21713 
      else:
21714 
        iprot.skip(ftype)
21715 
      iprot.readFieldEnd()
21716 
    iprot.readStructEnd()
21717 
 
21718 
  def write(self, oprot):
21719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21721 
      return
21722 
    oprot.writeStructBegin('addPageViewEvent_args')
21723 
    if self.pageViewEvents is not None:
21724 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21725 
      self.pageViewEvents.write(oprot)
21726 
      oprot.writeFieldEnd()
21727 
    oprot.writeFieldStop()
21728 
    oprot.writeStructEnd()
21729 
 
21730 
  def validate(self):
21731 
    return
21732 
 
21733 
 
21734 
  def __repr__(self):
21735 
    L = ['%s=%r' % (key, value)
21736 
      for key, value in self.__dict__.iteritems()]
21737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21738 
 
21739 
  def __eq__(self, other):
21740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21741 
 
21742 
  def __ne__(self, other):
21743 
    return not (self == other)
21744 
 
21745 
class addPageViewEvent_result:
21746 
 
21747 
  thrift_spec = (
21748 
  )
21749 
 
21750 
  def read(self, iprot):
21751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21753 
      return
21754 
    iprot.readStructBegin()
21755 
    while True:
21756 
      (fname, ftype, fid) = iprot.readFieldBegin()
21757 
      if ftype == TType.STOP:
21758 
        break
21759 
      else:
21760 
        iprot.skip(ftype)
21761 
      iprot.readFieldEnd()
21762 
    iprot.readStructEnd()
21763 
 
21764 
  def write(self, oprot):
21765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21767 
      return
21768 
    oprot.writeStructBegin('addPageViewEvent_result')
21769 
    oprot.writeFieldStop()
21770 
    oprot.writeStructEnd()
21771 
 
21772 
  def validate(self):
21773 
    return
21774 
 
21775 
 
21776 
  def __repr__(self):
21777 
    L = ['%s=%r' % (key, value)
21778 
      for key, value in self.__dict__.iteritems()]
21779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21780 
 
21781 
  def __eq__(self, other):
21782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21783 
 
21784 
  def __ne__(self, other):
21785 
    return not (self == other)
21786 
 
21787 
class addCartEvent_args:
21788 
  """
21789 
  Attributes:
21790 
   - cartEvents
21791 
  """
21792 
 
21793 
  thrift_spec = (
21794 
    None, # 0
21795 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21796 
  )
21797 
 
21798 
  def __init__(self, cartEvents=None,):
21799 
    self.cartEvents = cartEvents
21800 
 
21801 
  def read(self, iprot):
21802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21804 
      return
21805 
    iprot.readStructBegin()
21806 
    while True:
21807 
      (fname, ftype, fid) = iprot.readFieldBegin()
21808 
      if ftype == TType.STOP:
21809 
        break
21810 
      if fid == 1:
21811 
        if ftype == TType.STRUCT:
21812 
          self.cartEvents = CartEvents()
21813 
          self.cartEvents.read(iprot)
21814 
        else:
21815 
          iprot.skip(ftype)
21816 
      else:
21817 
        iprot.skip(ftype)
21818 
      iprot.readFieldEnd()
21819 
    iprot.readStructEnd()
21820 
 
21821 
  def write(self, oprot):
21822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21824 
      return
21825 
    oprot.writeStructBegin('addCartEvent_args')
21826 
    if self.cartEvents is not None:
21827 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21828 
      self.cartEvents.write(oprot)
21829 
      oprot.writeFieldEnd()
21830 
    oprot.writeFieldStop()
21831 
    oprot.writeStructEnd()
21832 
 
21833 
  def validate(self):
21834 
    return
21835 
 
21836 
 
21837 
  def __repr__(self):
21838 
    L = ['%s=%r' % (key, value)
21839 
      for key, value in self.__dict__.iteritems()]
21840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21841 
 
21842 
  def __eq__(self, other):
21843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21844 
 
21845 
  def __ne__(self, other):
21846 
    return not (self == other)
21847 
 
21848 
class addCartEvent_result:
21849 
 
21850 
  thrift_spec = (
21851 
  )
21852 
 
21853 
  def read(self, iprot):
21854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21856 
      return
21857 
    iprot.readStructBegin()
21858 
    while True:
21859 
      (fname, ftype, fid) = iprot.readFieldBegin()
21860 
      if ftype == TType.STOP:
21861 
        break
21862 
      else:
21863 
        iprot.skip(ftype)
21864 
      iprot.readFieldEnd()
21865 
    iprot.readStructEnd()
21866 
 
21867 
  def write(self, oprot):
21868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21870 
      return
21871 
    oprot.writeStructBegin('addCartEvent_result')
21872 
    oprot.writeFieldStop()
21873 
    oprot.writeStructEnd()
21874 
 
21875 
  def validate(self):
21876 
    return
21877 
 
21878 
 
21879 
  def __repr__(self):
21880 
    L = ['%s=%r' % (key, value)
21881 
      for key, value in self.__dict__.iteritems()]
21882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21883 
 
21884 
  def __eq__(self, other):
21885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21886 
 
21887 
  def __ne__(self, other):
21888 
    return not (self == other)
8139 kshitij.so 21889 
 
8182 amar.kumar 21890 
class addEbayItem_args:
21891 
  """
21892 
  Attributes:
21893 
   - ebayItem
21894 
  """
21895 
 
21896 
  thrift_spec = (
21897 
    None, # 0
21898 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21899 
  )
21900 
 
21901 
  def __init__(self, ebayItem=None,):
21902 
    self.ebayItem = ebayItem
21903 
 
21904 
  def read(self, iprot):
21905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21907 
      return
21908 
    iprot.readStructBegin()
21909 
    while True:
21910 
      (fname, ftype, fid) = iprot.readFieldBegin()
21911 
      if ftype == TType.STOP:
21912 
        break
21913 
      if fid == 1:
21914 
        if ftype == TType.STRUCT:
21915 
          self.ebayItem = EbayItem()
21916 
          self.ebayItem.read(iprot)
21917 
        else:
21918 
          iprot.skip(ftype)
21919 
      else:
21920 
        iprot.skip(ftype)
21921 
      iprot.readFieldEnd()
21922 
    iprot.readStructEnd()
21923 
 
21924 
  def write(self, oprot):
21925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21927 
      return
21928 
    oprot.writeStructBegin('addEbayItem_args')
21929 
    if self.ebayItem is not None:
21930 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21931 
      self.ebayItem.write(oprot)
21932 
      oprot.writeFieldEnd()
21933 
    oprot.writeFieldStop()
21934 
    oprot.writeStructEnd()
21935 
 
21936 
  def validate(self):
21937 
    return
21938 
 
21939 
 
21940 
  def __repr__(self):
21941 
    L = ['%s=%r' % (key, value)
21942 
      for key, value in self.__dict__.iteritems()]
21943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21944 
 
21945 
  def __eq__(self, other):
21946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21947 
 
21948 
  def __ne__(self, other):
21949 
    return not (self == other)
21950 
 
21951 
class addEbayItem_result:
21952 
 
21953 
  thrift_spec = (
21954 
  )
21955 
 
21956 
  def read(self, iprot):
21957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21959 
      return
21960 
    iprot.readStructBegin()
21961 
    while True:
21962 
      (fname, ftype, fid) = iprot.readFieldBegin()
21963 
      if ftype == TType.STOP:
21964 
        break
21965 
      else:
21966 
        iprot.skip(ftype)
21967 
      iprot.readFieldEnd()
21968 
    iprot.readStructEnd()
21969 
 
21970 
  def write(self, oprot):
21971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21973 
      return
21974 
    oprot.writeStructBegin('addEbayItem_result')
21975 
    oprot.writeFieldStop()
21976 
    oprot.writeStructEnd()
21977 
 
21978 
  def validate(self):
21979 
    return
21980 
 
21981 
 
21982 
  def __repr__(self):
21983 
    L = ['%s=%r' % (key, value)
21984 
      for key, value in self.__dict__.iteritems()]
21985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21986 
 
21987 
  def __eq__(self, other):
21988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21989 
 
21990 
  def __ne__(self, other):
21991 
    return not (self == other)
21992 
 
21993 
class getEbayItem_args:
21994 
  """
21995 
  Attributes:
21996 
   - listingId
21997 
  """
21998 
 
21999 
  thrift_spec = (
22000 
    None, # 0
22001 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22002 
  )
22003 
 
22004 
  def __init__(self, listingId=None,):
22005 
    self.listingId = listingId
22006 
 
22007 
  def read(self, iprot):
22008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22010 
      return
22011 
    iprot.readStructBegin()
22012 
    while True:
22013 
      (fname, ftype, fid) = iprot.readFieldBegin()
22014 
      if ftype == TType.STOP:
22015 
        break
22016 
      if fid == 1:
22017 
        if ftype == TType.STRING:
22018 
          self.listingId = iprot.readString();
22019 
        else:
22020 
          iprot.skip(ftype)
22021 
      else:
22022 
        iprot.skip(ftype)
22023 
      iprot.readFieldEnd()
22024 
    iprot.readStructEnd()
22025 
 
22026 
  def write(self, oprot):
22027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22029 
      return
22030 
    oprot.writeStructBegin('getEbayItem_args')
22031 
    if self.listingId is not None:
22032 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22033 
      oprot.writeString(self.listingId)
22034 
      oprot.writeFieldEnd()
22035 
    oprot.writeFieldStop()
22036 
    oprot.writeStructEnd()
22037 
 
22038 
  def validate(self):
22039 
    return
22040 
 
22041 
 
22042 
  def __repr__(self):
22043 
    L = ['%s=%r' % (key, value)
22044 
      for key, value in self.__dict__.iteritems()]
22045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22046 
 
22047 
  def __eq__(self, other):
22048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22049 
 
22050 
  def __ne__(self, other):
22051 
    return not (self == other)
22052 
 
22053 
class getEbayItem_result:
22054 
  """
22055 
  Attributes:
22056 
   - success
22057 
  """
22058 
 
22059 
  thrift_spec = (
22060 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22061 
  )
22062 
 
22063 
  def __init__(self, success=None,):
22064 
    self.success = success
22065 
 
22066 
  def read(self, iprot):
22067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22069 
      return
22070 
    iprot.readStructBegin()
22071 
    while True:
22072 
      (fname, ftype, fid) = iprot.readFieldBegin()
22073 
      if ftype == TType.STOP:
22074 
        break
22075 
      if fid == 0:
22076 
        if ftype == TType.STRUCT:
22077 
          self.success = EbayItem()
22078 
          self.success.read(iprot)
22079 
        else:
22080 
          iprot.skip(ftype)
22081 
      else:
22082 
        iprot.skip(ftype)
22083 
      iprot.readFieldEnd()
22084 
    iprot.readStructEnd()
22085 
 
22086 
  def write(self, oprot):
22087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22089 
      return
22090 
    oprot.writeStructBegin('getEbayItem_result')
22091 
    if self.success is not None:
22092 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22093 
      self.success.write(oprot)
22094 
      oprot.writeFieldEnd()
22095 
    oprot.writeFieldStop()
22096 
    oprot.writeStructEnd()
22097 
 
22098 
  def validate(self):
22099 
    return
22100 
 
22101 
 
22102 
  def __repr__(self):
22103 
    L = ['%s=%r' % (key, value)
22104 
      for key, value in self.__dict__.iteritems()]
22105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22106 
 
22107 
  def __eq__(self, other):
22108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22109 
 
22110 
  def __ne__(self, other):
22111 
    return not (self == other)
22112 
 
22113 
class updateEbayItem_args:
22114 
  """
22115 
  Attributes:
22116 
   - ebayItem
22117 
  """
22118 
 
22119 
  thrift_spec = (
22120 
    None, # 0
22121 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22122 
  )
22123 
 
22124 
  def __init__(self, ebayItem=None,):
22125 
    self.ebayItem = ebayItem
22126 
 
22127 
  def read(self, iprot):
22128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22130 
      return
22131 
    iprot.readStructBegin()
22132 
    while True:
22133 
      (fname, ftype, fid) = iprot.readFieldBegin()
22134 
      if ftype == TType.STOP:
22135 
        break
22136 
      if fid == 1:
22137 
        if ftype == TType.STRUCT:
22138 
          self.ebayItem = EbayItem()
22139 
          self.ebayItem.read(iprot)
22140 
        else:
22141 
          iprot.skip(ftype)
22142 
      else:
22143 
        iprot.skip(ftype)
22144 
      iprot.readFieldEnd()
22145 
    iprot.readStructEnd()
22146 
 
22147 
  def write(self, oprot):
22148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22150 
      return
22151 
    oprot.writeStructBegin('updateEbayItem_args')
22152 
    if self.ebayItem is not None:
22153 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22154 
      self.ebayItem.write(oprot)
22155 
      oprot.writeFieldEnd()
22156 
    oprot.writeFieldStop()
22157 
    oprot.writeStructEnd()
22158 
 
22159 
  def validate(self):
22160 
    return
22161 
 
22162 
 
22163 
  def __repr__(self):
22164 
    L = ['%s=%r' % (key, value)
22165 
      for key, value in self.__dict__.iteritems()]
22166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22167 
 
22168 
  def __eq__(self, other):
22169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22170 
 
22171 
  def __ne__(self, other):
22172 
    return not (self == other)
22173 
 
22174 
class updateEbayItem_result:
22175 
 
22176 
  thrift_spec = (
22177 
  )
22178 
 
22179 
  def read(self, iprot):
22180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22182 
      return
22183 
    iprot.readStructBegin()
22184 
    while True:
22185 
      (fname, ftype, fid) = iprot.readFieldBegin()
22186 
      if ftype == TType.STOP:
22187 
        break
22188 
      else:
22189 
        iprot.skip(ftype)
22190 
      iprot.readFieldEnd()
22191 
    iprot.readStructEnd()
22192 
 
22193 
  def write(self, oprot):
22194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22196 
      return
22197 
    oprot.writeStructBegin('updateEbayItem_result')
22198 
    oprot.writeFieldStop()
22199 
    oprot.writeStructEnd()
22200 
 
22201 
  def validate(self):
22202 
    return
22203 
 
22204 
 
22205 
  def __repr__(self):
22206 
    L = ['%s=%r' % (key, value)
22207 
      for key, value in self.__dict__.iteritems()]
22208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22209 
 
22210 
  def __eq__(self, other):
22211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22212 
 
22213 
  def __ne__(self, other):
22214 
    return not (self == other)
22215 
 
8139 kshitij.so 22216 
class getAmazonListedItems_args:
22217 
  """
22218 
  Attributes:
22219 
   - offset
22220 
   - limit
22221 
  """
22222 
 
22223 
  thrift_spec = (
22224 
    None, # 0
22225 
    (1, TType.I64, 'offset', None, None, ), # 1
22226 
    (2, TType.I64, 'limit', None, None, ), # 2
22227 
  )
22228 
 
22229 
  def __init__(self, offset=None, limit=None,):
22230 
    self.offset = offset
22231 
    self.limit = limit
22232 
 
22233 
  def read(self, iprot):
22234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22236 
      return
22237 
    iprot.readStructBegin()
22238 
    while True:
22239 
      (fname, ftype, fid) = iprot.readFieldBegin()
22240 
      if ftype == TType.STOP:
22241 
        break
22242 
      if fid == 1:
22243 
        if ftype == TType.I64:
22244 
          self.offset = iprot.readI64();
22245 
        else:
22246 
          iprot.skip(ftype)
22247 
      elif fid == 2:
22248 
        if ftype == TType.I64:
22249 
          self.limit = iprot.readI64();
22250 
        else:
22251 
          iprot.skip(ftype)
22252 
      else:
22253 
        iprot.skip(ftype)
22254 
      iprot.readFieldEnd()
22255 
    iprot.readStructEnd()
22256 
 
22257 
  def write(self, oprot):
22258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22260 
      return
22261 
    oprot.writeStructBegin('getAmazonListedItems_args')
22262 
    if self.offset is not None:
22263 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22264 
      oprot.writeI64(self.offset)
22265 
      oprot.writeFieldEnd()
22266 
    if self.limit is not None:
22267 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22268 
      oprot.writeI64(self.limit)
22269 
      oprot.writeFieldEnd()
22270 
    oprot.writeFieldStop()
22271 
    oprot.writeStructEnd()
22272 
 
22273 
  def validate(self):
22274 
    return
22275 
 
22276 
 
22277 
  def __repr__(self):
22278 
    L = ['%s=%r' % (key, value)
22279 
      for key, value in self.__dict__.iteritems()]
22280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22281 
 
22282 
  def __eq__(self, other):
22283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22284 
 
22285 
  def __ne__(self, other):
22286 
    return not (self == other)
22287 
 
22288 
class getAmazonListedItems_result:
22289 
  """
22290 
  Attributes:
22291 
   - success
22292 
  """
22293 
 
22294 
  thrift_spec = (
22295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22296 
  )
22297 
 
22298 
  def __init__(self, success=None,):
22299 
    self.success = success
22300 
 
22301 
  def read(self, iprot):
22302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22304 
      return
22305 
    iprot.readStructBegin()
22306 
    while True:
22307 
      (fname, ftype, fid) = iprot.readFieldBegin()
22308 
      if ftype == TType.STOP:
22309 
        break
22310 
      if fid == 0:
22311 
        if ftype == TType.LIST:
22312 
          self.success = []
9155 kshitij.so 22313 
          (_etype477, _size474) = iprot.readListBegin()
22314 
          for _i478 in xrange(_size474):
22315 
            _elem479 = Amazonlisted()
22316 
            _elem479.read(iprot)
22317 
            self.success.append(_elem479)
8139 kshitij.so 22318 
          iprot.readListEnd()
22319 
        else:
22320 
          iprot.skip(ftype)
22321 
      else:
22322 
        iprot.skip(ftype)
22323 
      iprot.readFieldEnd()
22324 
    iprot.readStructEnd()
22325 
 
22326 
  def write(self, oprot):
22327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22329 
      return
22330 
    oprot.writeStructBegin('getAmazonListedItems_result')
22331 
    if self.success is not None:
22332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22334 
      for iter480 in self.success:
22335 
        iter480.write(oprot)
8139 kshitij.so 22336 
      oprot.writeListEnd()
22337 
      oprot.writeFieldEnd()
22338 
    oprot.writeFieldStop()
22339 
    oprot.writeStructEnd()
22340 
 
22341 
  def validate(self):
22342 
    return
22343 
 
22344 
 
22345 
  def __repr__(self):
22346 
    L = ['%s=%r' % (key, value)
22347 
      for key, value in self.__dict__.iteritems()]
22348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22349 
 
22350 
  def __eq__(self, other):
22351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22352 
 
22353 
  def __ne__(self, other):
22354 
    return not (self == other)
8168 kshitij.so 22355 
 
22356 
class updateAmazonAttributesInBulk_args:
22357 
  """
22358 
  Attributes:
22359 
   - amazonlisted
22360 
  """
22361 
 
22362 
  thrift_spec = (
22363 
    None, # 0
22364 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22365 
  )
22366 
 
22367 
  def __init__(self, amazonlisted=None,):
22368 
    self.amazonlisted = amazonlisted
22369 
 
22370 
  def read(self, iprot):
22371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22373 
      return
22374 
    iprot.readStructBegin()
22375 
    while True:
22376 
      (fname, ftype, fid) = iprot.readFieldBegin()
22377 
      if ftype == TType.STOP:
22378 
        break
22379 
      if fid == 1:
22380 
        if ftype == TType.MAP:
22381 
          self.amazonlisted = {}
9155 kshitij.so 22382 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22383 
          for _i485 in xrange(_size481):
22384 
            _key486 = iprot.readI64();
22385 
            _val487 = Amazonlisted()
22386 
            _val487.read(iprot)
22387 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22388 
          iprot.readMapEnd()
22389 
        else:
22390 
          iprot.skip(ftype)
22391 
      else:
22392 
        iprot.skip(ftype)
22393 
      iprot.readFieldEnd()
22394 
    iprot.readStructEnd()
22395 
 
22396 
  def write(self, oprot):
22397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22399 
      return
22400 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22401 
    if self.amazonlisted is not None:
22402 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22403 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22404 
      for kiter488,viter489 in self.amazonlisted.items():
22405 
        oprot.writeI64(kiter488)
22406 
        viter489.write(oprot)
8168 kshitij.so 22407 
      oprot.writeMapEnd()
22408 
      oprot.writeFieldEnd()
22409 
    oprot.writeFieldStop()
22410 
    oprot.writeStructEnd()
22411 
 
22412 
  def validate(self):
22413 
    return
22414 
 
22415 
 
22416 
  def __repr__(self):
22417 
    L = ['%s=%r' % (key, value)
22418 
      for key, value in self.__dict__.iteritems()]
22419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22420 
 
22421 
  def __eq__(self, other):
22422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22423 
 
22424 
  def __ne__(self, other):
22425 
    return not (self == other)
22426 
 
22427 
class updateAmazonAttributesInBulk_result:
22428 
  """
22429 
  Attributes:
22430 
   - success
22431 
  """
22432 
 
22433 
  thrift_spec = (
22434 
    (0, TType.BOOL, 'success', None, None, ), # 0
22435 
  )
22436 
 
22437 
  def __init__(self, success=None,):
22438 
    self.success = success
22439 
 
22440 
  def read(self, iprot):
22441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22443 
      return
22444 
    iprot.readStructBegin()
22445 
    while True:
22446 
      (fname, ftype, fid) = iprot.readFieldBegin()
22447 
      if ftype == TType.STOP:
22448 
        break
22449 
      if fid == 0:
22450 
        if ftype == TType.BOOL:
22451 
          self.success = iprot.readBool();
22452 
        else:
22453 
          iprot.skip(ftype)
22454 
      else:
22455 
        iprot.skip(ftype)
22456 
      iprot.readFieldEnd()
22457 
    iprot.readStructEnd()
22458 
 
22459 
  def write(self, oprot):
22460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22462 
      return
22463 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22464 
    if self.success is not None:
22465 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22466 
      oprot.writeBool(self.success)
22467 
      oprot.writeFieldEnd()
22468 
    oprot.writeFieldStop()
22469 
    oprot.writeStructEnd()
22470 
 
22471 
  def validate(self):
22472 
    return
22473 
 
22474 
 
22475 
  def __repr__(self):
22476 
    L = ['%s=%r' % (key, value)
22477 
      for key, value in self.__dict__.iteritems()]
22478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22479 
 
22480 
  def __eq__(self, other):
22481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22482 
 
22483 
  def __ne__(self, other):
22484 
    return not (self == other)
8379 vikram.rag 22485 
 
22486 
class getAllItemstoListOnFba_args:
22487 
 
22488 
  thrift_spec = (
22489 
  )
22490 
 
22491 
  def read(self, iprot):
22492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22494 
      return
22495 
    iprot.readStructBegin()
22496 
    while True:
22497 
      (fname, ftype, fid) = iprot.readFieldBegin()
22498 
      if ftype == TType.STOP:
22499 
        break
22500 
      else:
22501 
        iprot.skip(ftype)
22502 
      iprot.readFieldEnd()
22503 
    iprot.readStructEnd()
22504 
 
22505 
  def write(self, oprot):
22506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22508 
      return
22509 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
22510 
    oprot.writeFieldStop()
22511 
    oprot.writeStructEnd()
22512 
 
22513 
  def validate(self):
22514 
    return
22515 
 
22516 
 
22517 
  def __repr__(self):
22518 
    L = ['%s=%r' % (key, value)
22519 
      for key, value in self.__dict__.iteritems()]
22520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22521 
 
22522 
  def __eq__(self, other):
22523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22524 
 
22525 
  def __ne__(self, other):
22526 
    return not (self == other)
22527 
 
22528 
class getAllItemstoListOnFba_result:
22529 
  """
22530 
  Attributes:
22531 
   - success
22532 
  """
22533 
 
22534 
  thrift_spec = (
22535 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22536 
  )
22537 
 
22538 
  def __init__(self, success=None,):
22539 
    self.success = success
22540 
 
22541 
  def read(self, iprot):
22542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22544 
      return
22545 
    iprot.readStructBegin()
22546 
    while True:
22547 
      (fname, ftype, fid) = iprot.readFieldBegin()
22548 
      if ftype == TType.STOP:
22549 
        break
22550 
      if fid == 0:
22551 
        if ftype == TType.LIST:
22552 
          self.success = []
9155 kshitij.so 22553 
          (_etype493, _size490) = iprot.readListBegin()
22554 
          for _i494 in xrange(_size490):
22555 
            _elem495 = Amazonlisted()
22556 
            _elem495.read(iprot)
22557 
            self.success.append(_elem495)
8379 vikram.rag 22558 
          iprot.readListEnd()
22559 
        else:
22560 
          iprot.skip(ftype)
22561 
      else:
22562 
        iprot.skip(ftype)
22563 
      iprot.readFieldEnd()
22564 
    iprot.readStructEnd()
22565 
 
22566 
  def write(self, oprot):
22567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22569 
      return
22570 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22571 
    if self.success is not None:
22572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22574 
      for iter496 in self.success:
22575 
        iter496.write(oprot)
8379 vikram.rag 22576 
      oprot.writeListEnd()
22577 
      oprot.writeFieldEnd()
22578 
    oprot.writeFieldStop()
22579 
    oprot.writeStructEnd()
22580 
 
22581 
  def validate(self):
22582 
    return
22583 
 
22584 
 
22585 
  def __repr__(self):
22586 
    L = ['%s=%r' % (key, value)
22587 
      for key, value in self.__dict__.iteritems()]
22588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22589 
 
22590 
  def __eq__(self, other):
22591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22592 
 
22593 
  def __ne__(self, other):
22594 
    return not (self == other)
22595 
 
22596 
class getAllItemstoListOnNonFba_args:
22597 
 
22598 
  thrift_spec = (
22599 
  )
22600 
 
22601 
  def read(self, iprot):
22602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22604 
      return
22605 
    iprot.readStructBegin()
22606 
    while True:
22607 
      (fname, ftype, fid) = iprot.readFieldBegin()
22608 
      if ftype == TType.STOP:
22609 
        break
22610 
      else:
22611 
        iprot.skip(ftype)
22612 
      iprot.readFieldEnd()
22613 
    iprot.readStructEnd()
22614 
 
22615 
  def write(self, oprot):
22616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22618 
      return
22619 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22620 
    oprot.writeFieldStop()
22621 
    oprot.writeStructEnd()
22622 
 
22623 
  def validate(self):
22624 
    return
22625 
 
22626 
 
22627 
  def __repr__(self):
22628 
    L = ['%s=%r' % (key, value)
22629 
      for key, value in self.__dict__.iteritems()]
22630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22631 
 
22632 
  def __eq__(self, other):
22633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22634 
 
22635 
  def __ne__(self, other):
22636 
    return not (self == other)
22637 
 
22638 
class getAllItemstoListOnNonFba_result:
22639 
  """
22640 
  Attributes:
22641 
   - success
22642 
  """
22643 
 
22644 
  thrift_spec = (
22645 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22646 
  )
22647 
 
22648 
  def __init__(self, success=None,):
22649 
    self.success = success
22650 
 
22651 
  def read(self, iprot):
22652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22654 
      return
22655 
    iprot.readStructBegin()
22656 
    while True:
22657 
      (fname, ftype, fid) = iprot.readFieldBegin()
22658 
      if ftype == TType.STOP:
22659 
        break
22660 
      if fid == 0:
22661 
        if ftype == TType.LIST:
22662 
          self.success = []
9155 kshitij.so 22663 
          (_etype500, _size497) = iprot.readListBegin()
22664 
          for _i501 in xrange(_size497):
22665 
            _elem502 = Amazonlisted()
22666 
            _elem502.read(iprot)
22667 
            self.success.append(_elem502)
8379 vikram.rag 22668 
          iprot.readListEnd()
22669 
        else:
22670 
          iprot.skip(ftype)
22671 
      else:
22672 
        iprot.skip(ftype)
22673 
      iprot.readFieldEnd()
22674 
    iprot.readStructEnd()
22675 
 
22676 
  def write(self, oprot):
22677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22679 
      return
22680 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22681 
    if self.success is not None:
22682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22684 
      for iter503 in self.success:
22685 
        iter503.write(oprot)
8379 vikram.rag 22686 
      oprot.writeListEnd()
22687 
      oprot.writeFieldEnd()
22688 
    oprot.writeFieldStop()
22689 
    oprot.writeStructEnd()
22690 
 
22691 
  def validate(self):
22692 
    return
22693 
 
22694 
 
22695 
  def __repr__(self):
22696 
    L = ['%s=%r' % (key, value)
22697 
      for key, value in self.__dict__.iteritems()]
22698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22699 
 
22700 
  def __eq__(self, other):
22701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22702 
 
22703 
  def __ne__(self, other):
22704 
    return not (self == other)
8616 vikram.rag 22705 
 
9242 kshitij.so 22706 
class updateAsin_args:
22707 
  """
22708 
  Attributes:
22709 
   - item
22710 
  """
8616 vikram.rag 22711 
 
22712 
  thrift_spec = (
9242 kshitij.so 22713 
    None, # 0
22714 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22715 
  )
22716 
 
9242 kshitij.so 22717 
  def __init__(self, item=None,):
22718 
    self.item = item
22719 
 
8616 vikram.rag 22720 
  def read(self, iprot):
22721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22723 
      return
22724 
    iprot.readStructBegin()
22725 
    while True:
22726 
      (fname, ftype, fid) = iprot.readFieldBegin()
22727 
      if ftype == TType.STOP:
22728 
        break
9242 kshitij.so 22729 
      if fid == 1:
22730 
        if ftype == TType.MAP:
22731 
          self.item = {}
22732 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22733 
          for _i508 in xrange(_size504):
22734 
            _key509 = iprot.readI64();
22735 
            _val510 = Item()
22736 
            _val510.read(iprot)
22737 
            self.item[_key509] = _val510
22738 
          iprot.readMapEnd()
22739 
        else:
22740 
          iprot.skip(ftype)
8616 vikram.rag 22741 
      else:
22742 
        iprot.skip(ftype)
22743 
      iprot.readFieldEnd()
22744 
    iprot.readStructEnd()
22745 
 
22746 
  def write(self, oprot):
22747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22749 
      return
9242 kshitij.so 22750 
    oprot.writeStructBegin('updateAsin_args')
22751 
    if self.item is not None:
22752 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22753 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22754 
      for kiter511,viter512 in self.item.items():
22755 
        oprot.writeI64(kiter511)
22756 
        viter512.write(oprot)
22757 
      oprot.writeMapEnd()
22758 
      oprot.writeFieldEnd()
8616 vikram.rag 22759 
    oprot.writeFieldStop()
22760 
    oprot.writeStructEnd()
22761 
 
22762 
  def validate(self):
22763 
    return
22764 
 
22765 
 
22766 
  def __repr__(self):
22767 
    L = ['%s=%r' % (key, value)
22768 
      for key, value in self.__dict__.iteritems()]
22769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22770 
 
22771 
  def __eq__(self, other):
22772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22773 
 
22774 
  def __ne__(self, other):
22775 
    return not (self == other)
22776 
 
9242 kshitij.so 22777 
class updateAsin_result:
8616 vikram.rag 22778 
 
22779 
  thrift_spec = (
22780 
  )
22781 
 
22782 
  def read(self, iprot):
22783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22785 
      return
22786 
    iprot.readStructBegin()
22787 
    while True:
22788 
      (fname, ftype, fid) = iprot.readFieldBegin()
22789 
      if ftype == TType.STOP:
22790 
        break
22791 
      else:
22792 
        iprot.skip(ftype)
22793 
      iprot.readFieldEnd()
22794 
    iprot.readStructEnd()
22795 
 
22796 
  def write(self, oprot):
22797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22799 
      return
9242 kshitij.so 22800 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22801 
    oprot.writeFieldStop()
22802 
    oprot.writeStructEnd()
22803 
 
22804 
  def validate(self):
22805 
    return
22806 
 
22807 
 
22808 
  def __repr__(self):
22809 
    L = ['%s=%r' % (key, value)
22810 
      for key, value in self.__dict__.iteritems()]
22811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22812 
 
22813 
  def __eq__(self, other):
22814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22815 
 
22816 
  def __ne__(self, other):
22817 
    return not (self == other)
8619 kshitij.so 22818 
 
9242 kshitij.so 22819 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22820 
  """
22821 
  Attributes:
9242 kshitij.so 22822 
   - snapdealitem
8619 kshitij.so 22823 
  """
22824 
 
9242 kshitij.so 22825 
  thrift_spec = None
22826 
  def __init__(self, snapdealitem=None,):
22827 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22828 
 
22829 
  def read(self, iprot):
22830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22832 
      return
22833 
    iprot.readStructBegin()
22834 
    while True:
22835 
      (fname, ftype, fid) = iprot.readFieldBegin()
22836 
      if ftype == TType.STOP:
22837 
        break
9242 kshitij.so 22838 
      if fid == -1:
22839 
        if ftype == TType.STRUCT:
22840 
          self.snapdealitem = SnapdealItem()
22841 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22842 
        else:
22843 
          iprot.skip(ftype)
22844 
      else:
22845 
        iprot.skip(ftype)
22846 
      iprot.readFieldEnd()
22847 
    iprot.readStructEnd()
22848 
 
22849 
  def write(self, oprot):
22850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22852 
      return
9242 kshitij.so 22853 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22854 
    if self.snapdealitem is not None:
22855 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22856 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22857 
      oprot.writeFieldEnd()
22858 
    oprot.writeFieldStop()
22859 
    oprot.writeStructEnd()
22860 
 
22861 
  def validate(self):
22862 
    return
22863 
 
22864 
 
22865 
  def __repr__(self):
22866 
    L = ['%s=%r' % (key, value)
22867 
      for key, value in self.__dict__.iteritems()]
22868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22869 
 
22870 
  def __eq__(self, other):
22871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22872 
 
22873 
  def __ne__(self, other):
22874 
    return not (self == other)
22875 
 
9242 kshitij.so 22876 
class addOrUpdateSnapdealItem_result:
22877 
  """
22878 
  Attributes:
22879 
   - success
22880 
  """
8619 kshitij.so 22881 
 
22882 
  thrift_spec = (
9242 kshitij.so 22883 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22884 
  )
22885 
 
9242 kshitij.so 22886 
  def __init__(self, success=None,):
22887 
    self.success = success
22888 
 
8619 kshitij.so 22889 
  def read(self, iprot):
22890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22892 
      return
22893 
    iprot.readStructBegin()
22894 
    while True:
22895 
      (fname, ftype, fid) = iprot.readFieldBegin()
22896 
      if ftype == TType.STOP:
22897 
        break
9242 kshitij.so 22898 
      if fid == 0:
22899 
        if ftype == TType.BOOL:
22900 
          self.success = iprot.readBool();
22901 
        else:
22902 
          iprot.skip(ftype)
8619 kshitij.so 22903 
      else:
22904 
        iprot.skip(ftype)
22905 
      iprot.readFieldEnd()
22906 
    iprot.readStructEnd()
22907 
 
22908 
  def write(self, oprot):
22909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22911 
      return
9242 kshitij.so 22912 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22913 
    if self.success is not None:
22914 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22915 
      oprot.writeBool(self.success)
22916 
      oprot.writeFieldEnd()
8619 kshitij.so 22917 
    oprot.writeFieldStop()
22918 
    oprot.writeStructEnd()
22919 
 
22920 
  def validate(self):
22921 
    return
22922 
 
22923 
 
22924 
  def __repr__(self):
22925 
    L = ['%s=%r' % (key, value)
22926 
      for key, value in self.__dict__.iteritems()]
22927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22928 
 
22929 
  def __eq__(self, other):
22930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22931 
 
22932 
  def __ne__(self, other):
22933 
    return not (self == other)
8739 vikram.rag 22934 
 
9242 kshitij.so 22935 
class getSnapdealItem_args:
8739 vikram.rag 22936 
  """
22937 
  Attributes:
9242 kshitij.so 22938 
   - item_id
8739 vikram.rag 22939 
  """
22940 
 
9242 kshitij.so 22941 
  thrift_spec = (
22942 
    None, # 0
22943 
    (1, TType.I64, 'item_id', None, None, ), # 1
22944 
  )
8739 vikram.rag 22945 
 
9242 kshitij.so 22946 
  def __init__(self, item_id=None,):
22947 
    self.item_id = item_id
22948 
 
8739 vikram.rag 22949 
  def read(self, iprot):
22950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22952 
      return
22953 
    iprot.readStructBegin()
22954 
    while True:
22955 
      (fname, ftype, fid) = iprot.readFieldBegin()
22956 
      if ftype == TType.STOP:
22957 
        break
9242 kshitij.so 22958 
      if fid == 1:
22959 
        if ftype == TType.I64:
22960 
          self.item_id = iprot.readI64();
8739 vikram.rag 22961 
        else:
22962 
          iprot.skip(ftype)
22963 
      else:
22964 
        iprot.skip(ftype)
22965 
      iprot.readFieldEnd()
22966 
    iprot.readStructEnd()
22967 
 
22968 
  def write(self, oprot):
22969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22971 
      return
9242 kshitij.so 22972 
    oprot.writeStructBegin('getSnapdealItem_args')
22973 
    if self.item_id is not None:
22974 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22975 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22976 
      oprot.writeFieldEnd()
22977 
    oprot.writeFieldStop()
22978 
    oprot.writeStructEnd()
22979 
 
22980 
  def validate(self):
22981 
    return
22982 
 
22983 
 
22984 
  def __repr__(self):
22985 
    L = ['%s=%r' % (key, value)
22986 
      for key, value in self.__dict__.iteritems()]
22987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22988 
 
22989 
  def __eq__(self, other):
22990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22991 
 
22992 
  def __ne__(self, other):
22993 
    return not (self == other)
22994 
 
9242 kshitij.so 22995 
class getSnapdealItem_result:
8739 vikram.rag 22996 
  """
22997 
  Attributes:
22998 
   - success
22999 
  """
23000 
 
23001 
  thrift_spec = (
9242 kshitij.so 23002 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23003 
  )
23004 
 
23005 
  def __init__(self, success=None,):
23006 
    self.success = success
23007 
 
23008 
  def read(self, iprot):
23009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23011 
      return
23012 
    iprot.readStructBegin()
23013 
    while True:
23014 
      (fname, ftype, fid) = iprot.readFieldBegin()
23015 
      if ftype == TType.STOP:
23016 
        break
23017 
      if fid == 0:
9242 kshitij.so 23018 
        if ftype == TType.STRUCT:
23019 
          self.success = SnapdealItem()
23020 
          self.success.read(iprot)
8739 vikram.rag 23021 
        else:
23022 
          iprot.skip(ftype)
23023 
      else:
23024 
        iprot.skip(ftype)
23025 
      iprot.readFieldEnd()
23026 
    iprot.readStructEnd()
23027 
 
23028 
  def write(self, oprot):
23029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23031 
      return
9242 kshitij.so 23032 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23033 
    if self.success is not None:
9242 kshitij.so 23034 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23035 
      self.success.write(oprot)
8739 vikram.rag 23036 
      oprot.writeFieldEnd()
23037 
    oprot.writeFieldStop()
23038 
    oprot.writeStructEnd()
23039 
 
23040 
  def validate(self):
23041 
    return
23042 
 
23043 
 
23044 
  def __repr__(self):
23045 
    L = ['%s=%r' % (key, value)
23046 
      for key, value in self.__dict__.iteritems()]
23047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23048 
 
23049 
  def __eq__(self, other):
23050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23051 
 
23052 
  def __ne__(self, other):
23053 
    return not (self == other)
23054 
 
9242 kshitij.so 23055 
class getSnapdealItemDetails_args:
8739 vikram.rag 23056 
  """
23057 
  Attributes:
23058 
   - item_id
23059 
  """
23060 
 
23061 
  thrift_spec = (
23062 
    None, # 0
23063 
    (1, TType.I64, 'item_id', None, None, ), # 1
23064 
  )
23065 
 
23066 
  def __init__(self, item_id=None,):
23067 
    self.item_id = item_id
23068 
 
23069 
  def read(self, iprot):
23070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23072 
      return
23073 
    iprot.readStructBegin()
23074 
    while True:
23075 
      (fname, ftype, fid) = iprot.readFieldBegin()
23076 
      if ftype == TType.STOP:
23077 
        break
23078 
      if fid == 1:
23079 
        if ftype == TType.I64:
23080 
          self.item_id = iprot.readI64();
23081 
        else:
23082 
          iprot.skip(ftype)
23083 
      else:
23084 
        iprot.skip(ftype)
23085 
      iprot.readFieldEnd()
23086 
    iprot.readStructEnd()
23087 
 
23088 
  def write(self, oprot):
23089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23091 
      return
9242 kshitij.so 23092 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23093 
    if self.item_id is not None:
23094 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23095 
      oprot.writeI64(self.item_id)
23096 
      oprot.writeFieldEnd()
23097 
    oprot.writeFieldStop()
23098 
    oprot.writeStructEnd()
23099 
 
23100 
  def validate(self):
23101 
    return
23102 
 
23103 
 
23104 
  def __repr__(self):
23105 
    L = ['%s=%r' % (key, value)
23106 
      for key, value in self.__dict__.iteritems()]
23107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23108 
 
23109 
  def __eq__(self, other):
23110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23111 
 
23112 
  def __ne__(self, other):
23113 
    return not (self == other)
23114 
 
9242 kshitij.so 23115 
class getSnapdealItemDetails_result:
8739 vikram.rag 23116 
  """
23117 
  Attributes:
23118 
   - success
23119 
  """
23120 
 
23121 
  thrift_spec = (
9242 kshitij.so 23122 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23123 
  )
23124 
 
23125 
  def __init__(self, success=None,):
23126 
    self.success = success
23127 
 
23128 
  def read(self, iprot):
23129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23131 
      return
23132 
    iprot.readStructBegin()
23133 
    while True:
23134 
      (fname, ftype, fid) = iprot.readFieldBegin()
23135 
      if ftype == TType.STOP:
23136 
        break
23137 
      if fid == 0:
23138 
        if ftype == TType.STRUCT:
9242 kshitij.so 23139 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23140 
          self.success.read(iprot)
23141 
        else:
23142 
          iprot.skip(ftype)
23143 
      else:
23144 
        iprot.skip(ftype)
23145 
      iprot.readFieldEnd()
23146 
    iprot.readStructEnd()
23147 
 
23148 
  def write(self, oprot):
23149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23151 
      return
9242 kshitij.so 23152 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23153 
    if self.success is not None:
23154 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23155 
      self.success.write(oprot)
23156 
      oprot.writeFieldEnd()
23157 
    oprot.writeFieldStop()
23158 
    oprot.writeStructEnd()
23159 
 
23160 
  def validate(self):
23161 
    return
23162 
 
23163 
 
23164 
  def __repr__(self):
23165 
    L = ['%s=%r' % (key, value)
23166 
      for key, value in self.__dict__.iteritems()]
23167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23168 
 
23169 
  def __eq__(self, other):
23170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23171 
 
23172 
  def __ne__(self, other):
23173 
    return not (self == other)
23174 
 
23175 
class getAllSnapdealItems_args:
23176 
 
23177 
  thrift_spec = (
23178 
  )
23179 
 
23180 
  def read(self, iprot):
23181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23183 
      return
23184 
    iprot.readStructBegin()
23185 
    while True:
23186 
      (fname, ftype, fid) = iprot.readFieldBegin()
23187 
      if ftype == TType.STOP:
23188 
        break
23189 
      else:
23190 
        iprot.skip(ftype)
23191 
      iprot.readFieldEnd()
23192 
    iprot.readStructEnd()
23193 
 
23194 
  def write(self, oprot):
23195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23197 
      return
23198 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23199 
    oprot.writeFieldStop()
23200 
    oprot.writeStructEnd()
23201 
 
23202 
  def validate(self):
23203 
    return
23204 
 
23205 
 
23206 
  def __repr__(self):
23207 
    L = ['%s=%r' % (key, value)
23208 
      for key, value in self.__dict__.iteritems()]
23209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23210 
 
23211 
  def __eq__(self, other):
23212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23213 
 
23214 
  def __ne__(self, other):
23215 
    return not (self == other)
23216 
 
23217 
class getAllSnapdealItems_result:
23218 
  """
23219 
  Attributes:
23220 
   - success
23221 
  """
23222 
 
23223 
  thrift_spec = (
9242 kshitij.so 23224 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23225 
  )
23226 
 
23227 
  def __init__(self, success=None,):
23228 
    self.success = success
23229 
 
23230 
  def read(self, iprot):
23231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23233 
      return
23234 
    iprot.readStructBegin()
23235 
    while True:
23236 
      (fname, ftype, fid) = iprot.readFieldBegin()
23237 
      if ftype == TType.STOP:
23238 
        break
23239 
      if fid == 0:
23240 
        if ftype == TType.LIST:
23241 
          self.success = []
9242 kshitij.so 23242 
          (_etype516, _size513) = iprot.readListBegin()
23243 
          for _i517 in xrange(_size513):
23244 
            _elem518 = SnapdealItemDetails()
23245 
            _elem518.read(iprot)
23246 
            self.success.append(_elem518)
23247 
          iprot.readListEnd()
23248 
        else:
23249 
          iprot.skip(ftype)
23250 
      else:
23251 
        iprot.skip(ftype)
23252 
      iprot.readFieldEnd()
23253 
    iprot.readStructEnd()
23254 
 
23255 
  def write(self, oprot):
23256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23258 
      return
23259 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23260 
    if self.success is not None:
23261 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23262 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23263 
      for iter519 in self.success:
23264 
        iter519.write(oprot)
23265 
      oprot.writeListEnd()
23266 
      oprot.writeFieldEnd()
23267 
    oprot.writeFieldStop()
23268 
    oprot.writeStructEnd()
23269 
 
23270 
  def validate(self):
23271 
    return
23272 
 
23273 
 
23274 
  def __repr__(self):
23275 
    L = ['%s=%r' % (key, value)
23276 
      for key, value in self.__dict__.iteritems()]
23277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23278 
 
23279 
  def __eq__(self, other):
23280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23281 
 
23282 
  def __ne__(self, other):
23283 
    return not (self == other)
23284 
 
23285 
class getSnapdealItems_args:
23286 
  """
23287 
  Attributes:
23288 
   - offset
23289 
   - limit
23290 
  """
23291 
 
23292 
  thrift_spec = (
23293 
    None, # 0
23294 
    (1, TType.I64, 'offset', None, None, ), # 1
23295 
    (2, TType.I64, 'limit', None, None, ), # 2
23296 
  )
23297 
 
23298 
  def __init__(self, offset=None, limit=None,):
23299 
    self.offset = offset
23300 
    self.limit = limit
23301 
 
23302 
  def read(self, iprot):
23303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23305 
      return
23306 
    iprot.readStructBegin()
23307 
    while True:
23308 
      (fname, ftype, fid) = iprot.readFieldBegin()
23309 
      if ftype == TType.STOP:
23310 
        break
23311 
      if fid == 1:
23312 
        if ftype == TType.I64:
23313 
          self.offset = iprot.readI64();
23314 
        else:
23315 
          iprot.skip(ftype)
23316 
      elif fid == 2:
23317 
        if ftype == TType.I64:
23318 
          self.limit = iprot.readI64();
23319 
        else:
23320 
          iprot.skip(ftype)
23321 
      else:
23322 
        iprot.skip(ftype)
23323 
      iprot.readFieldEnd()
23324 
    iprot.readStructEnd()
23325 
 
23326 
  def write(self, oprot):
23327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23329 
      return
23330 
    oprot.writeStructBegin('getSnapdealItems_args')
23331 
    if self.offset is not None:
23332 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23333 
      oprot.writeI64(self.offset)
23334 
      oprot.writeFieldEnd()
23335 
    if self.limit is not None:
23336 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23337 
      oprot.writeI64(self.limit)
23338 
      oprot.writeFieldEnd()
23339 
    oprot.writeFieldStop()
23340 
    oprot.writeStructEnd()
23341 
 
23342 
  def validate(self):
23343 
    return
23344 
 
23345 
 
23346 
  def __repr__(self):
23347 
    L = ['%s=%r' % (key, value)
23348 
      for key, value in self.__dict__.iteritems()]
23349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23350 
 
23351 
  def __eq__(self, other):
23352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23353 
 
23354 
  def __ne__(self, other):
23355 
    return not (self == other)
23356 
 
23357 
class getSnapdealItems_result:
23358 
  """
23359 
  Attributes:
23360 
   - success
23361 
  """
23362 
 
23363 
  thrift_spec = (
23364 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23365 
  )
23366 
 
23367 
  def __init__(self, success=None,):
23368 
    self.success = success
23369 
 
23370 
  def read(self, iprot):
23371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23373 
      return
23374 
    iprot.readStructBegin()
23375 
    while True:
23376 
      (fname, ftype, fid) = iprot.readFieldBegin()
23377 
      if ftype == TType.STOP:
23378 
        break
23379 
      if fid == 0:
23380 
        if ftype == TType.LIST:
23381 
          self.success = []
9155 kshitij.so 23382 
          (_etype523, _size520) = iprot.readListBegin()
23383 
          for _i524 in xrange(_size520):
9242 kshitij.so 23384 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23385 
            _elem525.read(iprot)
23386 
            self.success.append(_elem525)
8739 vikram.rag 23387 
          iprot.readListEnd()
23388 
        else:
23389 
          iprot.skip(ftype)
23390 
      else:
23391 
        iprot.skip(ftype)
23392 
      iprot.readFieldEnd()
23393 
    iprot.readStructEnd()
23394 
 
23395 
  def write(self, oprot):
23396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23398 
      return
9242 kshitij.so 23399 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23400 
    if self.success is not None:
23401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23403 
      for iter526 in self.success:
23404 
        iter526.write(oprot)
8739 vikram.rag 23405 
      oprot.writeListEnd()
23406 
      oprot.writeFieldEnd()
23407 
    oprot.writeFieldStop()
23408 
    oprot.writeStructEnd()
23409 
 
23410 
  def validate(self):
23411 
    return
23412 
 
23413 
 
23414 
  def __repr__(self):
23415 
    L = ['%s=%r' % (key, value)
23416 
      for key, value in self.__dict__.iteritems()]
23417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23418 
 
23419 
  def __eq__(self, other):
23420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23421 
 
23422 
  def __ne__(self, other):
23423 
    return not (self == other)
9242 kshitij.so 23424 
 
23425 
class searchSnapdealItems_args:
23426 
  """
23427 
  Attributes:
23428 
   - searchTerm
23429 
   - offset
23430 
   - limit
23431 
  """
23432 
 
23433 
  thrift_spec = (
23434 
    None, # 0
23435 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23436 
    (2, TType.I64, 'offset', None, None, ), # 2
23437 
    (3, TType.I64, 'limit', None, None, ), # 3
23438 
  )
23439 
 
23440 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23441 
    self.searchTerm = searchTerm
23442 
    self.offset = offset
23443 
    self.limit = limit
23444 
 
23445 
  def read(self, iprot):
23446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23448 
      return
23449 
    iprot.readStructBegin()
23450 
    while True:
23451 
      (fname, ftype, fid) = iprot.readFieldBegin()
23452 
      if ftype == TType.STOP:
23453 
        break
23454 
      if fid == 1:
23455 
        if ftype == TType.LIST:
23456 
          self.searchTerm = []
23457 
          (_etype530, _size527) = iprot.readListBegin()
23458 
          for _i531 in xrange(_size527):
23459 
            _elem532 = iprot.readString();
23460 
            self.searchTerm.append(_elem532)
23461 
          iprot.readListEnd()
23462 
        else:
23463 
          iprot.skip(ftype)
23464 
      elif fid == 2:
23465 
        if ftype == TType.I64:
23466 
          self.offset = iprot.readI64();
23467 
        else:
23468 
          iprot.skip(ftype)
23469 
      elif fid == 3:
23470 
        if ftype == TType.I64:
23471 
          self.limit = iprot.readI64();
23472 
        else:
23473 
          iprot.skip(ftype)
23474 
      else:
23475 
        iprot.skip(ftype)
23476 
      iprot.readFieldEnd()
23477 
    iprot.readStructEnd()
23478 
 
23479 
  def write(self, oprot):
23480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23482 
      return
23483 
    oprot.writeStructBegin('searchSnapdealItems_args')
23484 
    if self.searchTerm is not None:
23485 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23486 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23487 
      for iter533 in self.searchTerm:
23488 
        oprot.writeString(iter533)
23489 
      oprot.writeListEnd()
23490 
      oprot.writeFieldEnd()
23491 
    if self.offset is not None:
23492 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23493 
      oprot.writeI64(self.offset)
23494 
      oprot.writeFieldEnd()
23495 
    if self.limit is not None:
23496 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23497 
      oprot.writeI64(self.limit)
23498 
      oprot.writeFieldEnd()
23499 
    oprot.writeFieldStop()
23500 
    oprot.writeStructEnd()
23501 
 
23502 
  def validate(self):
23503 
    return
23504 
 
23505 
 
23506 
  def __repr__(self):
23507 
    L = ['%s=%r' % (key, value)
23508 
      for key, value in self.__dict__.iteritems()]
23509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23510 
 
23511 
  def __eq__(self, other):
23512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23513 
 
23514 
  def __ne__(self, other):
23515 
    return not (self == other)
23516 
 
23517 
class searchSnapdealItems_result:
23518 
  """
23519 
  Attributes:
23520 
   - success
23521 
  """
23522 
 
23523 
  thrift_spec = (
23524 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23525 
  )
23526 
 
23527 
  def __init__(self, success=None,):
23528 
    self.success = success
23529 
 
23530 
  def read(self, iprot):
23531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23533 
      return
23534 
    iprot.readStructBegin()
23535 
    while True:
23536 
      (fname, ftype, fid) = iprot.readFieldBegin()
23537 
      if ftype == TType.STOP:
23538 
        break
23539 
      if fid == 0:
23540 
        if ftype == TType.LIST:
23541 
          self.success = []
23542 
          (_etype537, _size534) = iprot.readListBegin()
23543 
          for _i538 in xrange(_size534):
23544 
            _elem539 = SnapdealItemDetails()
23545 
            _elem539.read(iprot)
23546 
            self.success.append(_elem539)
23547 
          iprot.readListEnd()
23548 
        else:
23549 
          iprot.skip(ftype)
23550 
      else:
23551 
        iprot.skip(ftype)
23552 
      iprot.readFieldEnd()
23553 
    iprot.readStructEnd()
23554 
 
23555 
  def write(self, oprot):
23556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23558 
      return
23559 
    oprot.writeStructBegin('searchSnapdealItems_result')
23560 
    if self.success is not None:
23561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23563 
      for iter540 in self.success:
23564 
        iter540.write(oprot)
23565 
      oprot.writeListEnd()
23566 
      oprot.writeFieldEnd()
23567 
    oprot.writeFieldStop()
23568 
    oprot.writeStructEnd()
23569 
 
23570 
  def validate(self):
23571 
    return
23572 
 
23573 
 
23574 
  def __repr__(self):
23575 
    L = ['%s=%r' % (key, value)
23576 
      for key, value in self.__dict__.iteritems()]
23577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23578 
 
23579 
  def __eq__(self, other):
23580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23581 
 
23582 
  def __ne__(self, other):
23583 
    return not (self == other)
23584 
 
23585 
class getCountForSnapdealItems_args:
23586 
 
23587 
  thrift_spec = (
23588 
  )
23589 
 
23590 
  def read(self, iprot):
23591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23593 
      return
23594 
    iprot.readStructBegin()
23595 
    while True:
23596 
      (fname, ftype, fid) = iprot.readFieldBegin()
23597 
      if ftype == TType.STOP:
23598 
        break
23599 
      else:
23600 
        iprot.skip(ftype)
23601 
      iprot.readFieldEnd()
23602 
    iprot.readStructEnd()
23603 
 
23604 
  def write(self, oprot):
23605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23607 
      return
23608 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23609 
    oprot.writeFieldStop()
23610 
    oprot.writeStructEnd()
23611 
 
23612 
  def validate(self):
23613 
    return
23614 
 
23615 
 
23616 
  def __repr__(self):
23617 
    L = ['%s=%r' % (key, value)
23618 
      for key, value in self.__dict__.iteritems()]
23619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23620 
 
23621 
  def __eq__(self, other):
23622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23623 
 
23624 
  def __ne__(self, other):
23625 
    return not (self == other)
23626 
 
23627 
class getCountForSnapdealItems_result:
23628 
  """
23629 
  Attributes:
23630 
   - success
23631 
  """
23632 
 
23633 
  thrift_spec = (
23634 
    (0, TType.I64, 'success', None, None, ), # 0
23635 
  )
23636 
 
23637 
  def __init__(self, success=None,):
23638 
    self.success = success
23639 
 
23640 
  def read(self, iprot):
23641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23643 
      return
23644 
    iprot.readStructBegin()
23645 
    while True:
23646 
      (fname, ftype, fid) = iprot.readFieldBegin()
23647 
      if ftype == TType.STOP:
23648 
        break
23649 
      if fid == 0:
23650 
        if ftype == TType.I64:
23651 
          self.success = iprot.readI64();
23652 
        else:
23653 
          iprot.skip(ftype)
23654 
      else:
23655 
        iprot.skip(ftype)
23656 
      iprot.readFieldEnd()
23657 
    iprot.readStructEnd()
23658 
 
23659 
  def write(self, oprot):
23660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23662 
      return
23663 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23664 
    if self.success is not None:
23665 
      oprot.writeFieldBegin('success', TType.I64, 0)
23666 
      oprot.writeI64(self.success)
23667 
      oprot.writeFieldEnd()
23668 
    oprot.writeFieldStop()
23669 
    oprot.writeStructEnd()
23670 
 
23671 
  def validate(self):
23672 
    return
23673 
 
23674 
 
23675 
  def __repr__(self):
23676 
    L = ['%s=%r' % (key, value)
23677 
      for key, value in self.__dict__.iteritems()]
23678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23679 
 
23680 
  def __eq__(self, other):
23681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23682 
 
23683 
  def __ne__(self, other):
23684 
    return not (self == other)
23685 
 
23686 
class getSnapdealSearchResultCount_args:
23687 
  """
23688 
  Attributes:
23689 
   - searchTerm
23690 
  """
23691 
 
23692 
  thrift_spec = (
23693 
    None, # 0
23694 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23695 
  )
23696 
 
23697 
  def __init__(self, searchTerm=None,):
23698 
    self.searchTerm = searchTerm
23699 
 
23700 
  def read(self, iprot):
23701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23703 
      return
23704 
    iprot.readStructBegin()
23705 
    while True:
23706 
      (fname, ftype, fid) = iprot.readFieldBegin()
23707 
      if ftype == TType.STOP:
23708 
        break
23709 
      if fid == 1:
23710 
        if ftype == TType.LIST:
23711 
          self.searchTerm = []
23712 
          (_etype544, _size541) = iprot.readListBegin()
23713 
          for _i545 in xrange(_size541):
23714 
            _elem546 = iprot.readString();
23715 
            self.searchTerm.append(_elem546)
23716 
          iprot.readListEnd()
23717 
        else:
23718 
          iprot.skip(ftype)
23719 
      else:
23720 
        iprot.skip(ftype)
23721 
      iprot.readFieldEnd()
23722 
    iprot.readStructEnd()
23723 
 
23724 
  def write(self, oprot):
23725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23727 
      return
23728 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23729 
    if self.searchTerm is not None:
23730 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23731 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23732 
      for iter547 in self.searchTerm:
23733 
        oprot.writeString(iter547)
23734 
      oprot.writeListEnd()
23735 
      oprot.writeFieldEnd()
23736 
    oprot.writeFieldStop()
23737 
    oprot.writeStructEnd()
23738 
 
23739 
  def validate(self):
23740 
    return
23741 
 
23742 
 
23743 
  def __repr__(self):
23744 
    L = ['%s=%r' % (key, value)
23745 
      for key, value in self.__dict__.iteritems()]
23746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23747 
 
23748 
  def __eq__(self, other):
23749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23750 
 
23751 
  def __ne__(self, other):
23752 
    return not (self == other)
23753 
 
23754 
class getSnapdealSearchResultCount_result:
23755 
  """
23756 
  Attributes:
23757 
   - success
23758 
  """
23759 
 
23760 
  thrift_spec = (
23761 
    (0, TType.I64, 'success', None, None, ), # 0
23762 
  )
23763 
 
23764 
  def __init__(self, success=None,):
23765 
    self.success = success
23766 
 
23767 
  def read(self, iprot):
23768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23770 
      return
23771 
    iprot.readStructBegin()
23772 
    while True:
23773 
      (fname, ftype, fid) = iprot.readFieldBegin()
23774 
      if ftype == TType.STOP:
23775 
        break
23776 
      if fid == 0:
23777 
        if ftype == TType.I64:
23778 
          self.success = iprot.readI64();
23779 
        else:
23780 
          iprot.skip(ftype)
23781 
      else:
23782 
        iprot.skip(ftype)
23783 
      iprot.readFieldEnd()
23784 
    iprot.readStructEnd()
23785 
 
23786 
  def write(self, oprot):
23787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23789 
      return
23790 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23791 
    if self.success is not None:
23792 
      oprot.writeFieldBegin('success', TType.I64, 0)
23793 
      oprot.writeI64(self.success)
23794 
      oprot.writeFieldEnd()
23795 
    oprot.writeFieldStop()
23796 
    oprot.writeStructEnd()
23797 
 
23798 
  def validate(self):
23799 
    return
23800 
 
23801 
 
23802 
  def __repr__(self):
23803 
    L = ['%s=%r' % (key, value)
23804 
      for key, value in self.__dict__.iteritems()]
23805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23806 
 
23807 
  def __eq__(self, other):
23808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23809 
 
23810 
  def __ne__(self, other):
23811 
    return not (self == other)
9299 kshitij.so 23812 
 
23813 
class getPrefferedInsurerForItem_args:
23814 
  """
23815 
  Attributes:
23816 
   - itemId
23817 
   - insurerType
23818 
  """
23819 
 
23820 
  thrift_spec = (
23821 
    None, # 0
23822 
    (1, TType.I64, 'itemId', None, None, ), # 1
23823 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23824 
  )
23825 
 
23826 
  def __init__(self, itemId=None, insurerType=None,):
23827 
    self.itemId = itemId
23828 
    self.insurerType = insurerType
23829 
 
23830 
  def read(self, iprot):
23831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23833 
      return
23834 
    iprot.readStructBegin()
23835 
    while True:
23836 
      (fname, ftype, fid) = iprot.readFieldBegin()
23837 
      if ftype == TType.STOP:
23838 
        break
23839 
      if fid == 1:
23840 
        if ftype == TType.I64:
23841 
          self.itemId = iprot.readI64();
23842 
        else:
23843 
          iprot.skip(ftype)
23844 
      elif fid == 2:
23845 
        if ftype == TType.I32:
23846 
          self.insurerType = iprot.readI32();
23847 
        else:
23848 
          iprot.skip(ftype)
23849 
      else:
23850 
        iprot.skip(ftype)
23851 
      iprot.readFieldEnd()
23852 
    iprot.readStructEnd()
23853 
 
23854 
  def write(self, oprot):
23855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23857 
      return
23858 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23859 
    if self.itemId is not None:
23860 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23861 
      oprot.writeI64(self.itemId)
23862 
      oprot.writeFieldEnd()
23863 
    if self.insurerType is not None:
23864 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23865 
      oprot.writeI32(self.insurerType)
23866 
      oprot.writeFieldEnd()
23867 
    oprot.writeFieldStop()
23868 
    oprot.writeStructEnd()
23869 
 
23870 
  def validate(self):
23871 
    return
23872 
 
23873 
 
23874 
  def __repr__(self):
23875 
    L = ['%s=%r' % (key, value)
23876 
      for key, value in self.__dict__.iteritems()]
23877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23878 
 
23879 
  def __eq__(self, other):
23880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23881 
 
23882 
  def __ne__(self, other):
23883 
    return not (self == other)
23884 
 
23885 
class getPrefferedInsurerForItem_result:
23886 
  """
23887 
  Attributes:
23888 
   - success
23889 
  """
23890 
 
23891 
  thrift_spec = (
23892 
    (0, TType.I64, 'success', None, None, ), # 0
23893 
  )
23894 
 
23895 
  def __init__(self, success=None,):
23896 
    self.success = success
23897 
 
23898 
  def read(self, iprot):
23899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23901 
      return
23902 
    iprot.readStructBegin()
23903 
    while True:
23904 
      (fname, ftype, fid) = iprot.readFieldBegin()
23905 
      if ftype == TType.STOP:
23906 
        break
23907 
      if fid == 0:
23908 
        if ftype == TType.I64:
23909 
          self.success = iprot.readI64();
23910 
        else:
23911 
          iprot.skip(ftype)
23912 
      else:
23913 
        iprot.skip(ftype)
23914 
      iprot.readFieldEnd()
23915 
    iprot.readStructEnd()
23916 
 
23917 
  def write(self, oprot):
23918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23920 
      return
23921 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
23922 
    if self.success is not None:
23923 
      oprot.writeFieldBegin('success', TType.I64, 0)
23924 
      oprot.writeI64(self.success)
23925 
      oprot.writeFieldEnd()
23926 
    oprot.writeFieldStop()
23927 
    oprot.writeStructEnd()
23928 
 
23929 
  def validate(self):
23930 
    return
23931 
 
23932 
 
23933 
  def __repr__(self):
23934 
    L = ['%s=%r' % (key, value)
23935 
      for key, value in self.__dict__.iteritems()]
23936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23937 
 
23938 
  def __eq__(self, other):
23939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23940 
 
23941 
  def __ne__(self, other):
23942 
    return not (self == other)
9456 vikram.rag 23943 
 
23944 
class getSnapdealItembySkuAtSnapdeal_args:
23945 
  """
23946 
  Attributes:
23947 
   - skuAtSnapdeal
23948 
  """
23949 
 
23950 
  thrift_spec = None
23951 
  def __init__(self, skuAtSnapdeal=None,):
23952 
    self.skuAtSnapdeal = skuAtSnapdeal
23953 
 
23954 
  def read(self, iprot):
23955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23957 
      return
23958 
    iprot.readStructBegin()
23959 
    while True:
23960 
      (fname, ftype, fid) = iprot.readFieldBegin()
23961 
      if ftype == TType.STOP:
23962 
        break
23963 
      if fid == -1:
23964 
        if ftype == TType.STRING:
23965 
          self.skuAtSnapdeal = iprot.readString();
23966 
        else:
23967 
          iprot.skip(ftype)
23968 
      else:
23969 
        iprot.skip(ftype)
23970 
      iprot.readFieldEnd()
23971 
    iprot.readStructEnd()
23972 
 
23973 
  def write(self, oprot):
23974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23976 
      return
23977 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
23978 
    if self.skuAtSnapdeal is not None:
23979 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
23980 
      oprot.writeString(self.skuAtSnapdeal)
23981 
      oprot.writeFieldEnd()
23982 
    oprot.writeFieldStop()
23983 
    oprot.writeStructEnd()
23984 
 
23985 
  def validate(self):
23986 
    return
23987 
 
23988 
 
23989 
  def __repr__(self):
23990 
    L = ['%s=%r' % (key, value)
23991 
      for key, value in self.__dict__.iteritems()]
23992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23993 
 
23994 
  def __eq__(self, other):
23995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23996 
 
23997 
  def __ne__(self, other):
23998 
    return not (self == other)
23999 
 
24000 
class getSnapdealItembySkuAtSnapdeal_result:
24001 
  """
24002 
  Attributes:
24003 
   - success
24004 
  """
24005 
 
24006 
  thrift_spec = (
24007 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24008 
  )
24009 
 
24010 
  def __init__(self, success=None,):
24011 
    self.success = success
24012 
 
24013 
  def read(self, iprot):
24014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24016 
      return
24017 
    iprot.readStructBegin()
24018 
    while True:
24019 
      (fname, ftype, fid) = iprot.readFieldBegin()
24020 
      if ftype == TType.STOP:
24021 
        break
24022 
      if fid == 0:
24023 
        if ftype == TType.STRUCT:
24024 
          self.success = SnapdealItem()
24025 
          self.success.read(iprot)
24026 
        else:
24027 
          iprot.skip(ftype)
24028 
      else:
24029 
        iprot.skip(ftype)
24030 
      iprot.readFieldEnd()
24031 
    iprot.readStructEnd()
24032 
 
24033 
  def write(self, oprot):
24034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24036 
      return
24037 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24038 
    if self.success is not None:
24039 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24040 
      self.success.write(oprot)
24041 
      oprot.writeFieldEnd()
24042 
    oprot.writeFieldStop()
24043 
    oprot.writeStructEnd()
24044 
 
24045 
  def validate(self):
24046 
    return
24047 
 
24048 
 
24049 
  def __repr__(self):
24050 
    L = ['%s=%r' % (key, value)
24051 
      for key, value in self.__dict__.iteritems()]
24052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24053 
 
24054 
  def __eq__(self, other):
24055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24056 
 
24057 
  def __ne__(self, other):
24058 
    return not (self == other)
9621 manish.sha 24059 
 
24060 
class getProductFeedSubmit_args:
24061 
  """
24062 
  Attributes:
24063 
   - catalogItemId
24064 
  """
24065 
 
24066 
  thrift_spec = (
24067 
    None, # 0
24068 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24069 
  )
24070 
 
24071 
  def __init__(self, catalogItemId=None,):
24072 
    self.catalogItemId = catalogItemId
24073 
 
24074 
  def read(self, iprot):
24075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24077 
      return
24078 
    iprot.readStructBegin()
24079 
    while True:
24080 
      (fname, ftype, fid) = iprot.readFieldBegin()
24081 
      if ftype == TType.STOP:
24082 
        break
24083 
      if fid == 1:
24084 
        if ftype == TType.I64:
24085 
          self.catalogItemId = iprot.readI64();
24086 
        else:
24087 
          iprot.skip(ftype)
24088 
      else:
24089 
        iprot.skip(ftype)
24090 
      iprot.readFieldEnd()
24091 
    iprot.readStructEnd()
24092 
 
24093 
  def write(self, oprot):
24094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24096 
      return
24097 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24098 
    if self.catalogItemId is not None:
24099 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24100 
      oprot.writeI64(self.catalogItemId)
24101 
      oprot.writeFieldEnd()
24102 
    oprot.writeFieldStop()
24103 
    oprot.writeStructEnd()
24104 
 
24105 
  def validate(self):
24106 
    return
24107 
 
24108 
 
24109 
  def __repr__(self):
24110 
    L = ['%s=%r' % (key, value)
24111 
      for key, value in self.__dict__.iteritems()]
24112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24113 
 
24114 
  def __eq__(self, other):
24115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24116 
 
24117 
  def __ne__(self, other):
24118 
    return not (self == other)
24119 
 
24120 
class getProductFeedSubmit_result:
24121 
  """
24122 
  Attributes:
24123 
   - success
24124 
   - cex
24125 
  """
24126 
 
24127 
  thrift_spec = (
24128 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24129 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24130 
  )
24131 
 
24132 
  def __init__(self, success=None, cex=None,):
24133 
    self.success = success
24134 
    self.cex = cex
24135 
 
24136 
  def read(self, iprot):
24137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24139 
      return
24140 
    iprot.readStructBegin()
24141 
    while True:
24142 
      (fname, ftype, fid) = iprot.readFieldBegin()
24143 
      if ftype == TType.STOP:
24144 
        break
24145 
      if fid == 0:
24146 
        if ftype == TType.STRUCT:
24147 
          self.success = ProductFeedSubmit()
24148 
          self.success.read(iprot)
24149 
        else:
24150 
          iprot.skip(ftype)
24151 
      elif fid == 1:
24152 
        if ftype == TType.STRUCT:
24153 
          self.cex = CatalogServiceException()
24154 
          self.cex.read(iprot)
24155 
        else:
24156 
          iprot.skip(ftype)
24157 
      else:
24158 
        iprot.skip(ftype)
24159 
      iprot.readFieldEnd()
24160 
    iprot.readStructEnd()
24161 
 
24162 
  def write(self, oprot):
24163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24165 
      return
24166 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24167 
    if self.success is not None:
24168 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24169 
      self.success.write(oprot)
24170 
      oprot.writeFieldEnd()
24171 
    if self.cex is not None:
24172 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24173 
      self.cex.write(oprot)
24174 
      oprot.writeFieldEnd()
24175 
    oprot.writeFieldStop()
24176 
    oprot.writeStructEnd()
24177 
 
24178 
  def validate(self):
24179 
    return
24180 
 
24181 
 
24182 
  def __repr__(self):
24183 
    L = ['%s=%r' % (key, value)
24184 
      for key, value in self.__dict__.iteritems()]
24185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24186 
 
24187 
  def __eq__(self, other):
24188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24189 
 
24190 
  def __ne__(self, other):
24191 
    return not (self == other)
24192 
 
24193 
class addProductFeedSubmit_args:
24194 
  """
24195 
  Attributes:
24196 
   - productFeedSubmit
24197 
  """
24198 
 
24199 
  thrift_spec = (
24200 
    None, # 0
24201 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24202 
  )
24203 
 
24204 
  def __init__(self, productFeedSubmit=None,):
24205 
    self.productFeedSubmit = productFeedSubmit
24206 
 
24207 
  def read(self, iprot):
24208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24210 
      return
24211 
    iprot.readStructBegin()
24212 
    while True:
24213 
      (fname, ftype, fid) = iprot.readFieldBegin()
24214 
      if ftype == TType.STOP:
24215 
        break
24216 
      if fid == 1:
24217 
        if ftype == TType.STRUCT:
24218 
          self.productFeedSubmit = ProductFeedSubmit()
24219 
          self.productFeedSubmit.read(iprot)
24220 
        else:
24221 
          iprot.skip(ftype)
24222 
      else:
24223 
        iprot.skip(ftype)
24224 
      iprot.readFieldEnd()
24225 
    iprot.readStructEnd()
24226 
 
24227 
  def write(self, oprot):
24228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24230 
      return
24231 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24232 
    if self.productFeedSubmit is not None:
24233 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24234 
      self.productFeedSubmit.write(oprot)
24235 
      oprot.writeFieldEnd()
24236 
    oprot.writeFieldStop()
24237 
    oprot.writeStructEnd()
24238 
 
24239 
  def validate(self):
24240 
    return
24241 
 
24242 
 
24243 
  def __repr__(self):
24244 
    L = ['%s=%r' % (key, value)
24245 
      for key, value in self.__dict__.iteritems()]
24246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24247 
 
24248 
  def __eq__(self, other):
24249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24250 
 
24251 
  def __ne__(self, other):
24252 
    return not (self == other)
24253 
 
24254 
class addProductFeedSubmit_result:
24255 
  """
24256 
  Attributes:
24257 
   - success
24258 
   - cex
24259 
  """
24260 
 
24261 
  thrift_spec = (
24262 
    (0, TType.BOOL, 'success', None, None, ), # 0
24263 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24264 
  )
24265 
 
24266 
  def __init__(self, success=None, cex=None,):
24267 
    self.success = success
24268 
    self.cex = cex
24269 
 
24270 
  def read(self, iprot):
24271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24273 
      return
24274 
    iprot.readStructBegin()
24275 
    while True:
24276 
      (fname, ftype, fid) = iprot.readFieldBegin()
24277 
      if ftype == TType.STOP:
24278 
        break
24279 
      if fid == 0:
24280 
        if ftype == TType.BOOL:
24281 
          self.success = iprot.readBool();
24282 
        else:
24283 
          iprot.skip(ftype)
24284 
      elif fid == 1:
24285 
        if ftype == TType.STRUCT:
24286 
          self.cex = CatalogServiceException()
24287 
          self.cex.read(iprot)
24288 
        else:
24289 
          iprot.skip(ftype)
24290 
      else:
24291 
        iprot.skip(ftype)
24292 
      iprot.readFieldEnd()
24293 
    iprot.readStructEnd()
24294 
 
24295 
  def write(self, oprot):
24296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24298 
      return
24299 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24300 
    if self.success is not None:
24301 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24302 
      oprot.writeBool(self.success)
24303 
      oprot.writeFieldEnd()
24304 
    if self.cex is not None:
24305 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24306 
      self.cex.write(oprot)
24307 
      oprot.writeFieldEnd()
24308 
    oprot.writeFieldStop()
24309 
    oprot.writeStructEnd()
24310 
 
24311 
  def validate(self):
24312 
    return
24313 
 
24314 
 
24315 
  def __repr__(self):
24316 
    L = ['%s=%r' % (key, value)
24317 
      for key, value in self.__dict__.iteritems()]
24318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24319 
 
24320 
  def __eq__(self, other):
24321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24322 
 
24323 
  def __ne__(self, other):
24324 
    return not (self == other)
24325 
 
24326 
class updateProductFeedSubmit_args:
24327 
  """
24328 
  Attributes:
24329 
   - productFeedSubmit
24330 
  """
24331 
 
24332 
  thrift_spec = (
24333 
    None, # 0
24334 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24335 
  )
24336 
 
24337 
  def __init__(self, productFeedSubmit=None,):
24338 
    self.productFeedSubmit = productFeedSubmit
24339 
 
24340 
  def read(self, iprot):
24341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24343 
      return
24344 
    iprot.readStructBegin()
24345 
    while True:
24346 
      (fname, ftype, fid) = iprot.readFieldBegin()
24347 
      if ftype == TType.STOP:
24348 
        break
24349 
      if fid == 1:
24350 
        if ftype == TType.STRUCT:
24351 
          self.productFeedSubmit = ProductFeedSubmit()
24352 
          self.productFeedSubmit.read(iprot)
24353 
        else:
24354 
          iprot.skip(ftype)
24355 
      else:
24356 
        iprot.skip(ftype)
24357 
      iprot.readFieldEnd()
24358 
    iprot.readStructEnd()
24359 
 
24360 
  def write(self, oprot):
24361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24363 
      return
24364 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24365 
    if self.productFeedSubmit is not None:
24366 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24367 
      self.productFeedSubmit.write(oprot)
24368 
      oprot.writeFieldEnd()
24369 
    oprot.writeFieldStop()
24370 
    oprot.writeStructEnd()
24371 
 
24372 
  def validate(self):
24373 
    return
24374 
 
24375 
 
24376 
  def __repr__(self):
24377 
    L = ['%s=%r' % (key, value)
24378 
      for key, value in self.__dict__.iteritems()]
24379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24380 
 
24381 
  def __eq__(self, other):
24382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24383 
 
24384 
  def __ne__(self, other):
24385 
    return not (self == other)
24386 
 
24387 
class updateProductFeedSubmit_result:
24388 
  """
24389 
  Attributes:
24390 
   - success
24391 
   - cex
24392 
  """
24393 
 
24394 
  thrift_spec = (
24395 
    (0, TType.BOOL, 'success', None, None, ), # 0
24396 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24397 
  )
24398 
 
24399 
  def __init__(self, success=None, cex=None,):
24400 
    self.success = success
24401 
    self.cex = cex
24402 
 
24403 
  def read(self, iprot):
24404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24406 
      return
24407 
    iprot.readStructBegin()
24408 
    while True:
24409 
      (fname, ftype, fid) = iprot.readFieldBegin()
24410 
      if ftype == TType.STOP:
24411 
        break
24412 
      if fid == 0:
24413 
        if ftype == TType.BOOL:
24414 
          self.success = iprot.readBool();
24415 
        else:
24416 
          iprot.skip(ftype)
24417 
      elif fid == 1:
24418 
        if ftype == TType.STRUCT:
24419 
          self.cex = CatalogServiceException()
24420 
          self.cex.read(iprot)
24421 
        else:
24422 
          iprot.skip(ftype)
24423 
      else:
24424 
        iprot.skip(ftype)
24425 
      iprot.readFieldEnd()
24426 
    iprot.readStructEnd()
24427 
 
24428 
  def write(self, oprot):
24429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24431 
      return
24432 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24433 
    if self.success is not None:
24434 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24435 
      oprot.writeBool(self.success)
24436 
      oprot.writeFieldEnd()
24437 
    if self.cex is not None:
24438 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24439 
      self.cex.write(oprot)
24440 
      oprot.writeFieldEnd()
24441 
    oprot.writeFieldStop()
24442 
    oprot.writeStructEnd()
24443 
 
24444 
  def validate(self):
24445 
    return
24446 
 
24447 
 
24448 
  def __repr__(self):
24449 
    L = ['%s=%r' % (key, value)
24450 
      for key, value in self.__dict__.iteritems()]
24451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24452 
 
24453 
  def __eq__(self, other):
24454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24455 
 
24456 
  def __ne__(self, other):
24457 
    return not (self == other)
24458 
 
24459 
class deleteProductFeedSubmit_args:
24460 
  """
24461 
  Attributes:
24462 
   - catalogItemId
24463 
  """
24464 
 
24465 
  thrift_spec = (
24466 
    None, # 0
24467 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24468 
  )
24469 
 
24470 
  def __init__(self, catalogItemId=None,):
24471 
    self.catalogItemId = catalogItemId
24472 
 
24473 
  def read(self, iprot):
24474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24476 
      return
24477 
    iprot.readStructBegin()
24478 
    while True:
24479 
      (fname, ftype, fid) = iprot.readFieldBegin()
24480 
      if ftype == TType.STOP:
24481 
        break
24482 
      if fid == 1:
24483 
        if ftype == TType.I64:
24484 
          self.catalogItemId = iprot.readI64();
24485 
        else:
24486 
          iprot.skip(ftype)
24487 
      else:
24488 
        iprot.skip(ftype)
24489 
      iprot.readFieldEnd()
24490 
    iprot.readStructEnd()
24491 
 
24492 
  def write(self, oprot):
24493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24495 
      return
24496 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24497 
    if self.catalogItemId is not None:
24498 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24499 
      oprot.writeI64(self.catalogItemId)
24500 
      oprot.writeFieldEnd()
24501 
    oprot.writeFieldStop()
24502 
    oprot.writeStructEnd()
24503 
 
24504 
  def validate(self):
24505 
    return
24506 
 
24507 
 
24508 
  def __repr__(self):
24509 
    L = ['%s=%r' % (key, value)
24510 
      for key, value in self.__dict__.iteritems()]
24511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24512 
 
24513 
  def __eq__(self, other):
24514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24515 
 
24516 
  def __ne__(self, other):
24517 
    return not (self == other)
24518 
 
24519 
class deleteProductFeedSubmit_result:
24520 
  """
24521 
  Attributes:
24522 
   - success
24523 
   - cex
24524 
  """
24525 
 
24526 
  thrift_spec = (
24527 
    (0, TType.BOOL, 'success', None, None, ), # 0
24528 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24529 
  )
24530 
 
24531 
  def __init__(self, success=None, cex=None,):
24532 
    self.success = success
24533 
    self.cex = cex
24534 
 
24535 
  def read(self, iprot):
24536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24538 
      return
24539 
    iprot.readStructBegin()
24540 
    while True:
24541 
      (fname, ftype, fid) = iprot.readFieldBegin()
24542 
      if ftype == TType.STOP:
24543 
        break
24544 
      if fid == 0:
24545 
        if ftype == TType.BOOL:
24546 
          self.success = iprot.readBool();
24547 
        else:
24548 
          iprot.skip(ftype)
24549 
      elif fid == 1:
24550 
        if ftype == TType.STRUCT:
24551 
          self.cex = CatalogServiceException()
24552 
          self.cex.read(iprot)
24553 
        else:
24554 
          iprot.skip(ftype)
24555 
      else:
24556 
        iprot.skip(ftype)
24557 
      iprot.readFieldEnd()
24558 
    iprot.readStructEnd()
24559 
 
24560 
  def write(self, oprot):
24561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24563 
      return
24564 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24565 
    if self.success is not None:
24566 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24567 
      oprot.writeBool(self.success)
24568 
      oprot.writeFieldEnd()
24569 
    if self.cex is not None:
24570 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24571 
      self.cex.write(oprot)
24572 
      oprot.writeFieldEnd()
24573 
    oprot.writeFieldStop()
24574 
    oprot.writeStructEnd()
24575 
 
24576 
  def validate(self):
24577 
    return
24578 
 
24579 
 
24580 
  def __repr__(self):
24581 
    L = ['%s=%r' % (key, value)
24582 
      for key, value in self.__dict__.iteritems()]
24583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24584 
 
24585 
  def __eq__(self, other):
24586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24587 
 
24588 
  def __ne__(self, other):
24589 
    return not (self == other)
24590 
 
24591 
class getAllProductFeedSubmit_args:
24592 
 
24593 
  thrift_spec = (
24594 
  )
24595 
 
24596 
  def read(self, iprot):
24597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24599 
      return
24600 
    iprot.readStructBegin()
24601 
    while True:
24602 
      (fname, ftype, fid) = iprot.readFieldBegin()
24603 
      if ftype == TType.STOP:
24604 
        break
24605 
      else:
24606 
        iprot.skip(ftype)
24607 
      iprot.readFieldEnd()
24608 
    iprot.readStructEnd()
24609 
 
24610 
  def write(self, oprot):
24611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24613 
      return
24614 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24615 
    oprot.writeFieldStop()
24616 
    oprot.writeStructEnd()
24617 
 
24618 
  def validate(self):
24619 
    return
24620 
 
24621 
 
24622 
  def __repr__(self):
24623 
    L = ['%s=%r' % (key, value)
24624 
      for key, value in self.__dict__.iteritems()]
24625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24626 
 
24627 
  def __eq__(self, other):
24628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24629 
 
24630 
  def __ne__(self, other):
24631 
    return not (self == other)
24632 
 
24633 
class getAllProductFeedSubmit_result:
24634 
  """
24635 
  Attributes:
24636 
   - success
24637 
   - cex
24638 
  """
24639 
 
24640 
  thrift_spec = (
24641 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24642 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24643 
  )
24644 
 
24645 
  def __init__(self, success=None, cex=None,):
24646 
    self.success = success
24647 
    self.cex = cex
24648 
 
24649 
  def read(self, iprot):
24650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24652 
      return
24653 
    iprot.readStructBegin()
24654 
    while True:
24655 
      (fname, ftype, fid) = iprot.readFieldBegin()
24656 
      if ftype == TType.STOP:
24657 
        break
24658 
      if fid == 0:
24659 
        if ftype == TType.LIST:
24660 
          self.success = []
24661 
          (_etype551, _size548) = iprot.readListBegin()
24662 
          for _i552 in xrange(_size548):
24663 
            _elem553 = ProductFeedSubmit()
24664 
            _elem553.read(iprot)
24665 
            self.success.append(_elem553)
24666 
          iprot.readListEnd()
24667 
        else:
24668 
          iprot.skip(ftype)
24669 
      elif fid == 1:
24670 
        if ftype == TType.STRUCT:
24671 
          self.cex = CatalogServiceException()
24672 
          self.cex.read(iprot)
24673 
        else:
24674 
          iprot.skip(ftype)
24675 
      else:
24676 
        iprot.skip(ftype)
24677 
      iprot.readFieldEnd()
24678 
    iprot.readStructEnd()
24679 
 
24680 
  def write(self, oprot):
24681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24683 
      return
24684 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24685 
    if self.success is not None:
24686 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24687 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24688 
      for iter554 in self.success:
24689 
        iter554.write(oprot)
24690 
      oprot.writeListEnd()
24691 
      oprot.writeFieldEnd()
24692 
    if self.cex is not None:
24693 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24694 
      self.cex.write(oprot)
24695 
      oprot.writeFieldEnd()
24696 
    oprot.writeFieldStop()
24697 
    oprot.writeStructEnd()
24698 
 
24699 
  def validate(self):
24700 
    return
24701 
 
24702 
 
24703 
  def __repr__(self):
24704 
    L = ['%s=%r' % (key, value)
24705 
      for key, value in self.__dict__.iteritems()]
24706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24707 
 
24708 
  def __eq__(self, other):
24709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24710 
 
24711 
  def __ne__(self, other):
24712 
    return not (self == other)
9724 kshitij.so 24713 
 
24714 
class getMarketplacedetailsForItem_args:
24715 
  """
24716 
  Attributes:
24717 
   - itemId
24718 
   - sourceId
24719 
  """
24720 
 
24721 
  thrift_spec = (
24722 
    None, # 0
24723 
    (1, TType.I64, 'itemId', None, None, ), # 1
24724 
    (2, TType.I64, 'sourceId', None, None, ), # 2
24725 
  )
24726 
 
24727 
  def __init__(self, itemId=None, sourceId=None,):
24728 
    self.itemId = itemId
24729 
    self.sourceId = sourceId
24730 
 
24731 
  def read(self, iprot):
24732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24734 
      return
24735 
    iprot.readStructBegin()
24736 
    while True:
24737 
      (fname, ftype, fid) = iprot.readFieldBegin()
24738 
      if ftype == TType.STOP:
24739 
        break
24740 
      if fid == 1:
24741 
        if ftype == TType.I64:
24742 
          self.itemId = iprot.readI64();
24743 
        else:
24744 
          iprot.skip(ftype)
24745 
      elif fid == 2:
24746 
        if ftype == TType.I64:
24747 
          self.sourceId = iprot.readI64();
24748 
        else:
24749 
          iprot.skip(ftype)
24750 
      else:
24751 
        iprot.skip(ftype)
24752 
      iprot.readFieldEnd()
24753 
    iprot.readStructEnd()
24754 
 
24755 
  def write(self, oprot):
24756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24758 
      return
24759 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
24760 
    if self.itemId is not None:
24761 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24762 
      oprot.writeI64(self.itemId)
24763 
      oprot.writeFieldEnd()
24764 
    if self.sourceId is not None:
24765 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
24766 
      oprot.writeI64(self.sourceId)
24767 
      oprot.writeFieldEnd()
24768 
    oprot.writeFieldStop()
24769 
    oprot.writeStructEnd()
24770 
 
24771 
  def validate(self):
24772 
    return
24773 
 
24774 
 
24775 
  def __repr__(self):
24776 
    L = ['%s=%r' % (key, value)
24777 
      for key, value in self.__dict__.iteritems()]
24778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24779 
 
24780 
  def __eq__(self, other):
24781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24782 
 
24783 
  def __ne__(self, other):
24784 
    return not (self == other)
24785 
 
24786 
class getMarketplacedetailsForItem_result:
24787 
  """
24788 
  Attributes:
24789 
   - success
24790 
  """
24791 
 
24792 
  thrift_spec = (
24793 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
24794 
  )
24795 
 
24796 
  def __init__(self, success=None,):
24797 
    self.success = success
24798 
 
24799 
  def read(self, iprot):
24800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24802 
      return
24803 
    iprot.readStructBegin()
24804 
    while True:
24805 
      (fname, ftype, fid) = iprot.readFieldBegin()
24806 
      if ftype == TType.STOP:
24807 
        break
24808 
      if fid == 0:
24809 
        if ftype == TType.STRUCT:
24810 
          self.success = MarketplaceItems()
24811 
          self.success.read(iprot)
24812 
        else:
24813 
          iprot.skip(ftype)
24814 
      else:
24815 
        iprot.skip(ftype)
24816 
      iprot.readFieldEnd()
24817 
    iprot.readStructEnd()
24818 
 
24819 
  def write(self, oprot):
24820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24822 
      return
24823 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
24824 
    if self.success is not None:
24825 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24826 
      self.success.write(oprot)
24827 
      oprot.writeFieldEnd()
24828 
    oprot.writeFieldStop()
24829 
    oprot.writeStructEnd()
24830 
 
24831 
  def validate(self):
24832 
    return
24833 
 
24834 
 
24835 
  def __repr__(self):
24836 
    L = ['%s=%r' % (key, value)
24837 
      for key, value in self.__dict__.iteritems()]
24838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24839 
 
24840 
  def __eq__(self, other):
24841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24842 
 
24843 
  def __ne__(self, other):
24844 
    return not (self == other)
24845 
 
24846 
class updateMarketplaceAttributesForItem_args:
24847 
  """
24848 
  Attributes:
24849 
   - marketPlaceItem
24850 
  """
24851 
 
24852 
  thrift_spec = (
24853 
    None, # 0
24854 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
24855 
  )
24856 
 
24857 
  def __init__(self, marketPlaceItem=None,):
24858 
    self.marketPlaceItem = marketPlaceItem
24859 
 
24860 
  def read(self, iprot):
24861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24863 
      return
24864 
    iprot.readStructBegin()
24865 
    while True:
24866 
      (fname, ftype, fid) = iprot.readFieldBegin()
24867 
      if ftype == TType.STOP:
24868 
        break
24869 
      if fid == 1:
24870 
        if ftype == TType.STRUCT:
24871 
          self.marketPlaceItem = MarketplaceItems()
24872 
          self.marketPlaceItem.read(iprot)
24873 
        else:
24874 
          iprot.skip(ftype)
24875 
      else:
24876 
        iprot.skip(ftype)
24877 
      iprot.readFieldEnd()
24878 
    iprot.readStructEnd()
24879 
 
24880 
  def write(self, oprot):
24881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24883 
      return
24884 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
24885 
    if self.marketPlaceItem is not None:
24886 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
24887 
      self.marketPlaceItem.write(oprot)
24888 
      oprot.writeFieldEnd()
24889 
    oprot.writeFieldStop()
24890 
    oprot.writeStructEnd()
24891 
 
24892 
  def validate(self):
24893 
    return
24894 
 
24895 
 
24896 
  def __repr__(self):
24897 
    L = ['%s=%r' % (key, value)
24898 
      for key, value in self.__dict__.iteritems()]
24899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24900 
 
24901 
  def __eq__(self, other):
24902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24903 
 
24904 
  def __ne__(self, other):
24905 
    return not (self == other)
24906 
 
24907 
class updateMarketplaceAttributesForItem_result:
24908 
  """
24909 
  Attributes:
24910 
   - success
24911 
  """
24912 
 
24913 
  thrift_spec = (
24914 
    (0, TType.BOOL, 'success', None, None, ), # 0
24915 
  )
24916 
 
24917 
  def __init__(self, success=None,):
24918 
    self.success = success
24919 
 
24920 
  def read(self, iprot):
24921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24923 
      return
24924 
    iprot.readStructBegin()
24925 
    while True:
24926 
      (fname, ftype, fid) = iprot.readFieldBegin()
24927 
      if ftype == TType.STOP:
24928 
        break
24929 
      if fid == 0:
24930 
        if ftype == TType.BOOL:
24931 
          self.success = iprot.readBool();
24932 
        else:
24933 
          iprot.skip(ftype)
24934 
      else:
24935 
        iprot.skip(ftype)
24936 
      iprot.readFieldEnd()
24937 
    iprot.readStructEnd()
24938 
 
24939 
  def write(self, oprot):
24940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24942 
      return
24943 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
24944 
    if self.success is not None:
24945 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24946 
      oprot.writeBool(self.success)
24947 
      oprot.writeFieldEnd()
24948 
    oprot.writeFieldStop()
24949 
    oprot.writeStructEnd()
24950 
 
24951 
  def validate(self):
24952 
    return
24953 
 
24954 
 
24955 
  def __repr__(self):
24956 
    L = ['%s=%r' % (key, value)
24957 
      for key, value in self.__dict__.iteritems()]
24958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24959 
 
24960 
  def __eq__(self, other):
24961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24962 
 
24963 
  def __ne__(self, other):
24964 
    return not (self == other)
9776 vikram.rag 24965 
 
9779 kshitij.so 24966 
class getCostingForMarketplace_args:
24967 
  """
24968 
  Attributes:
24969 
   - source
24970 
   - item_id
24971 
  """
24972 
 
24973 
  thrift_spec = (
24974 
    None, # 0
24975 
    (1, TType.I64, 'source', None, None, ), # 1
24976 
    (2, TType.I64, 'item_id', None, None, ), # 2
24977 
  )
24978 
 
24979 
  def __init__(self, source=None, item_id=None,):
24980 
    self.source = source
24981 
    self.item_id = item_id
24982 
 
24983 
  def read(self, iprot):
24984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24986 
      return
24987 
    iprot.readStructBegin()
24988 
    while True:
24989 
      (fname, ftype, fid) = iprot.readFieldBegin()
24990 
      if ftype == TType.STOP:
24991 
        break
24992 
      if fid == 1:
24993 
        if ftype == TType.I64:
24994 
          self.source = iprot.readI64();
24995 
        else:
24996 
          iprot.skip(ftype)
24997 
      elif fid == 2:
24998 
        if ftype == TType.I64:
24999 
          self.item_id = iprot.readI64();
25000 
        else:
25001 
          iprot.skip(ftype)
25002 
      else:
25003 
        iprot.skip(ftype)
25004 
      iprot.readFieldEnd()
25005 
    iprot.readStructEnd()
25006 
 
25007 
  def write(self, oprot):
25008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25010 
      return
25011 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25012 
    if self.source is not None:
25013 
      oprot.writeFieldBegin('source', TType.I64, 1)
25014 
      oprot.writeI64(self.source)
25015 
      oprot.writeFieldEnd()
25016 
    if self.item_id is not None:
25017 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25018 
      oprot.writeI64(self.item_id)
25019 
      oprot.writeFieldEnd()
25020 
    oprot.writeFieldStop()
25021 
    oprot.writeStructEnd()
25022 
 
25023 
  def validate(self):
25024 
    return
25025 
 
25026 
 
25027 
  def __repr__(self):
25028 
    L = ['%s=%r' % (key, value)
25029 
      for key, value in self.__dict__.iteritems()]
25030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25031 
 
25032 
  def __eq__(self, other):
25033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25034 
 
25035 
  def __ne__(self, other):
25036 
    return not (self == other)
25037 
 
25038 
class getCostingForMarketplace_result:
25039 
  """
25040 
  Attributes:
25041 
   - success
25042 
  """
25043 
 
25044 
  thrift_spec = (
25045 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25046 
  )
25047 
 
25048 
  def __init__(self, success=None,):
25049 
    self.success = success
25050 
 
25051 
  def read(self, iprot):
25052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25054 
      return
25055 
    iprot.readStructBegin()
25056 
    while True:
25057 
      (fname, ftype, fid) = iprot.readFieldBegin()
25058 
      if ftype == TType.STOP:
25059 
        break
25060 
      if fid == 0:
25061 
        if ftype == TType.STRUCT:
25062 
          self.success = MarketplacePercentage()
25063 
          self.success.read(iprot)
25064 
        else:
25065 
          iprot.skip(ftype)
25066 
      else:
25067 
        iprot.skip(ftype)
25068 
      iprot.readFieldEnd()
25069 
    iprot.readStructEnd()
25070 
 
25071 
  def write(self, oprot):
25072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25074 
      return
25075 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25076 
    if self.success is not None:
25077 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25078 
      self.success.write(oprot)
25079 
      oprot.writeFieldEnd()
25080 
    oprot.writeFieldStop()
25081 
    oprot.writeStructEnd()
25082 
 
25083 
  def validate(self):
25084 
    return
25085 
 
25086 
 
25087 
  def __repr__(self):
25088 
    L = ['%s=%r' % (key, value)
25089 
      for key, value in self.__dict__.iteritems()]
25090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25091 
 
25092 
  def __eq__(self, other):
25093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25094 
 
25095 
  def __ne__(self, other):
25096 
    return not (self == other)
25097 
 
9776 vikram.rag 25098 
class getMarketPlaceItemsForPriceUpdate_args:
25099 
  """
25100 
  Attributes:
25101 
   - source
25102 
  """
25103 
 
25104 
  thrift_spec = (
25105 
    None, # 0
25106 
    (1, TType.I64, 'source', None, None, ), # 1
25107 
  )
25108 
 
25109 
  def __init__(self, source=None,):
25110 
    self.source = source
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 1:
25122 
        if ftype == TType.I64:
25123 
          self.source = iprot.readI64();
25124 
        else:
25125 
          iprot.skip(ftype)
25126 
      else:
25127 
        iprot.skip(ftype)
25128 
      iprot.readFieldEnd()
25129 
    iprot.readStructEnd()
25130 
 
25131 
  def write(self, oprot):
25132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25134 
      return
25135 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25136 
    if self.source is not None:
25137 
      oprot.writeFieldBegin('source', TType.I64, 1)
25138 
      oprot.writeI64(self.source)
25139 
      oprot.writeFieldEnd()
25140 
    oprot.writeFieldStop()
25141 
    oprot.writeStructEnd()
25142 
 
25143 
  def validate(self):
25144 
    return
25145 
 
25146 
 
25147 
  def __repr__(self):
25148 
    L = ['%s=%r' % (key, value)
25149 
      for key, value in self.__dict__.iteritems()]
25150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25151 
 
25152 
  def __eq__(self, other):
25153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25154 
 
25155 
  def __ne__(self, other):
25156 
    return not (self == other)
25157 
 
25158 
class getMarketPlaceItemsForPriceUpdate_result:
25159 
  """
25160 
  Attributes:
25161 
   - success
25162 
  """
25163 
 
25164 
  thrift_spec = (
25165 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25166 
  )
25167 
 
25168 
  def __init__(self, success=None,):
25169 
    self.success = success
25170 
 
25171 
  def read(self, iprot):
25172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25174 
      return
25175 
    iprot.readStructBegin()
25176 
    while True:
25177 
      (fname, ftype, fid) = iprot.readFieldBegin()
25178 
      if ftype == TType.STOP:
25179 
        break
25180 
      if fid == 0:
25181 
        if ftype == TType.LIST:
25182 
          self.success = []
25183 
          (_etype558, _size555) = iprot.readListBegin()
25184 
          for _i559 in xrange(_size555):
25185 
            _elem560 = MarketPlaceItemPrice()
25186 
            _elem560.read(iprot)
25187 
            self.success.append(_elem560)
25188 
          iprot.readListEnd()
25189 
        else:
25190 
          iprot.skip(ftype)
25191 
      else:
25192 
        iprot.skip(ftype)
25193 
      iprot.readFieldEnd()
25194 
    iprot.readStructEnd()
25195 
 
25196 
  def write(self, oprot):
25197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25199 
      return
25200 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25201 
    if self.success is not None:
25202 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25203 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25204 
      for iter561 in self.success:
25205 
        iter561.write(oprot)
25206 
      oprot.writeListEnd()
25207 
      oprot.writeFieldEnd()
25208 
    oprot.writeFieldStop()
25209 
    oprot.writeStructEnd()
25210 
 
25211 
  def validate(self):
25212 
    return
25213 
 
25214 
 
25215 
  def __repr__(self):
25216 
    L = ['%s=%r' % (key, value)
25217 
      for key, value in self.__dict__.iteritems()]
25218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25219 
 
25220 
  def __eq__(self, other):
25221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25222 
 
25223 
  def __ne__(self, other):
25224 
    return not (self == other)
25225 
 
25226 
class updateMarketPlacePriceUpdateStatus_args:
25227 
  """
25228 
  Attributes:
25229 
   - skulist
25230 
   - timestamp
9816 kshitij.so 25231 
   - source
9776 vikram.rag 25232 
  """
25233 
 
25234 
  thrift_spec = (
25235 
    None, # 0
25236 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25237 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25238 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25239 
  )
25240 
 
9816 kshitij.so 25241 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25242 
    self.skulist = skulist
25243 
    self.timestamp = timestamp
9816 kshitij.so 25244 
    self.source = source
9776 vikram.rag 25245 
 
25246 
  def read(self, iprot):
25247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25249 
      return
25250 
    iprot.readStructBegin()
25251 
    while True:
25252 
      (fname, ftype, fid) = iprot.readFieldBegin()
25253 
      if ftype == TType.STOP:
25254 
        break
25255 
      if fid == 1:
25256 
        if ftype == TType.LIST:
25257 
          self.skulist = []
25258 
          (_etype565, _size562) = iprot.readListBegin()
25259 
          for _i566 in xrange(_size562):
25260 
            _elem567 = iprot.readI64();
25261 
            self.skulist.append(_elem567)
25262 
          iprot.readListEnd()
25263 
        else:
25264 
          iprot.skip(ftype)
25265 
      elif fid == 2:
25266 
        if ftype == TType.I64:
25267 
          self.timestamp = iprot.readI64();
25268 
        else:
25269 
          iprot.skip(ftype)
9816 kshitij.so 25270 
      elif fid == 3:
25271 
        if ftype == TType.I64:
25272 
          self.source = iprot.readI64();
25273 
        else:
25274 
          iprot.skip(ftype)
9776 vikram.rag 25275 
      else:
25276 
        iprot.skip(ftype)
25277 
      iprot.readFieldEnd()
25278 
    iprot.readStructEnd()
25279 
 
25280 
  def write(self, oprot):
25281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25283 
      return
25284 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25285 
    if self.skulist is not None:
25286 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25287 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25288 
      for iter568 in self.skulist:
25289 
        oprot.writeI64(iter568)
25290 
      oprot.writeListEnd()
25291 
      oprot.writeFieldEnd()
25292 
    if self.timestamp is not None:
25293 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25294 
      oprot.writeI64(self.timestamp)
25295 
      oprot.writeFieldEnd()
9816 kshitij.so 25296 
    if self.source is not None:
25297 
      oprot.writeFieldBegin('source', TType.I64, 3)
25298 
      oprot.writeI64(self.source)
25299 
      oprot.writeFieldEnd()
9776 vikram.rag 25300 
    oprot.writeFieldStop()
25301 
    oprot.writeStructEnd()
25302 
 
25303 
  def validate(self):
25304 
    return
25305 
 
25306 
 
25307 
  def __repr__(self):
25308 
    L = ['%s=%r' % (key, value)
25309 
      for key, value in self.__dict__.iteritems()]
25310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25311 
 
25312 
  def __eq__(self, other):
25313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25314 
 
25315 
  def __ne__(self, other):
25316 
    return not (self == other)
25317 
 
25318 
class updateMarketPlacePriceUpdateStatus_result:
25319 
 
25320 
  thrift_spec = (
25321 
  )
25322 
 
25323 
  def read(self, iprot):
25324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25326 
      return
25327 
    iprot.readStructBegin()
25328 
    while True:
25329 
      (fname, ftype, fid) = iprot.readFieldBegin()
25330 
      if ftype == TType.STOP:
25331 
        break
25332 
      else:
25333 
        iprot.skip(ftype)
25334 
      iprot.readFieldEnd()
25335 
    iprot.readStructEnd()
25336 
 
25337 
  def write(self, oprot):
25338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25340 
      return
25341 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25342 
    oprot.writeFieldStop()
25343 
    oprot.writeStructEnd()
25344 
 
25345 
  def validate(self):
25346 
    return
25347 
 
25348 
 
25349 
  def __repr__(self):
25350 
    L = ['%s=%r' % (key, value)
25351 
      for key, value in self.__dict__.iteritems()]
25352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25353 
 
25354 
  def __eq__(self, other):
25355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25356 
 
25357 
  def __ne__(self, other):
25358 
    return not (self == other)