Subversion Repositories SmartDukaan

Rev

Rev 9724 | Rev 9779 | 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 
 
9776 vikram.rag 1013 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1014 
    """
1015 
    Parameters:
1016 
     - source
1017 
    """
1018 
    pass
9724 kshitij.so 1019 
 
9776 vikram.rag 1020 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp):
1021 
    """
1022 
    Parameters:
1023 
     - skulist
1024 
     - timestamp
1025 
    """
1026 
    pass
1027 
 
1028 
 
5944 mandeep.dh 1029 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1030 
  def __init__(self, iprot, oprot=None):
1031 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1032 
 
1033 
  def addItem(self, item):
1034 
    """
1035 
    Availability and inventory attributes
1036 
 
1037 
    Parameters:
1038 
     - item
1039 
    """
1040 
    self.send_addItem(item)
1041 
    return self.recv_addItem()
1042 
 
1043 
  def send_addItem(self, item):
1044 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1045 
    args = addItem_args()
1046 
    args.item = item
1047 
    args.write(self._oprot)
1048 
    self._oprot.writeMessageEnd()
1049 
    self._oprot.trans.flush()
1050 
 
1051 
  def recv_addItem(self, ):
1052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1053 
    if mtype == TMessageType.EXCEPTION:
1054 
      x = TApplicationException()
1055 
      x.read(self._iprot)
1056 
      self._iprot.readMessageEnd()
1057 
      raise x
1058 
    result = addItem_result()
1059 
    result.read(self._iprot)
1060 
    self._iprot.readMessageEnd()
1061 
    if result.success is not None:
1062 
      return result.success
1063 
    if result.cex is not None:
1064 
      raise result.cex
1065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1066 
 
1067 
  def updateItem(self, item):
1068 
    """
1069 
    Parameters:
1070 
     - item
1071 
    """
1072 
    self.send_updateItem(item)
1073 
    return self.recv_updateItem()
1074 
 
1075 
  def send_updateItem(self, item):
1076 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1077 
    args = updateItem_args()
1078 
    args.item = item
1079 
    args.write(self._oprot)
1080 
    self._oprot.writeMessageEnd()
1081 
    self._oprot.trans.flush()
1082 
 
1083 
  def recv_updateItem(self, ):
1084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1085 
    if mtype == TMessageType.EXCEPTION:
1086 
      x = TApplicationException()
1087 
      x.read(self._iprot)
1088 
      self._iprot.readMessageEnd()
1089 
      raise x
1090 
    result = updateItem_result()
1091 
    result.read(self._iprot)
1092 
    self._iprot.readMessageEnd()
1093 
    if result.success is not None:
1094 
      return result.success
1095 
    if result.cex is not None:
1096 
      raise result.cex
1097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1098 
 
1099 
  def isActive(self, itemId):
1100 
    """
1101 
    Checks if the item given to the corresponding itemId is active. If it's active,
1102 
    whether it's risky and if it's risky, its inventory position.
1103 
 
1104 
    Parameters:
1105 
     - itemId
1106 
    """
1107 
    self.send_isActive(itemId)
1108 
    return self.recv_isActive()
1109 
 
1110 
  def send_isActive(self, itemId):
1111 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1112 
    args = isActive_args()
1113 
    args.itemId = itemId
1114 
    args.write(self._oprot)
1115 
    self._oprot.writeMessageEnd()
1116 
    self._oprot.trans.flush()
1117 
 
1118 
  def recv_isActive(self, ):
1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1120 
    if mtype == TMessageType.EXCEPTION:
1121 
      x = TApplicationException()
1122 
      x.read(self._iprot)
1123 
      self._iprot.readMessageEnd()
1124 
      raise x
1125 
    result = isActive_result()
1126 
    result.read(self._iprot)
1127 
    self._iprot.readMessageEnd()
1128 
    if result.success is not None:
1129 
      return result.success
1130 
    if result.isex is not None:
1131 
      raise result.isex
1132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1133 
 
7438 amit.gupta 1134 
  def getItemsStatus(self, itemIds):
1135 
    """
1136 
    Parameters:
1137 
     - itemIds
1138 
    """
1139 
    self.send_getItemsStatus(itemIds)
1140 
    return self.recv_getItemsStatus()
1141 
 
1142 
  def send_getItemsStatus(self, itemIds):
1143 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1144 
    args = getItemsStatus_args()
1145 
    args.itemIds = itemIds
1146 
    args.write(self._oprot)
1147 
    self._oprot.writeMessageEnd()
1148 
    self._oprot.trans.flush()
1149 
 
1150 
  def recv_getItemsStatus(self, ):
1151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1152 
    if mtype == TMessageType.EXCEPTION:
1153 
      x = TApplicationException()
1154 
      x.read(self._iprot)
1155 
      self._iprot.readMessageEnd()
1156 
      raise x
1157 
    result = getItemsStatus_result()
1158 
    result.read(self._iprot)
1159 
    self._iprot.readMessageEnd()
1160 
    if result.success is not None:
1161 
      return result.success
1162 
    if result.isex is not None:
1163 
      raise result.isex
1164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1165 
 
5944 mandeep.dh 1166 
  def getItemStatusDescription(self, itemId):
1167 
    """
1168 
    Parameters:
1169 
     - itemId
1170 
    """
1171 
    self.send_getItemStatusDescription(itemId)
1172 
    return self.recv_getItemStatusDescription()
1173 
 
1174 
  def send_getItemStatusDescription(self, itemId):
1175 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1176 
    args = getItemStatusDescription_args()
1177 
    args.itemId = itemId
1178 
    args.write(self._oprot)
1179 
    self._oprot.writeMessageEnd()
1180 
    self._oprot.trans.flush()
1181 
 
1182 
  def recv_getItemStatusDescription(self, ):
1183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1184 
    if mtype == TMessageType.EXCEPTION:
1185 
      x = TApplicationException()
1186 
      x.read(self._iprot)
1187 
      self._iprot.readMessageEnd()
1188 
      raise x
1189 
    result = getItemStatusDescription_result()
1190 
    result.read(self._iprot)
1191 
    self._iprot.readMessageEnd()
1192 
    if result.success is not None:
1193 
      return result.success
1194 
    if result.isex is not None:
1195 
      raise result.isex
1196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1197 
 
1198 
  def startItemOn(self, item_id, timestamp):
1199 
    """
1200 
    Parameters:
1201 
     - item_id
1202 
     - timestamp
1203 
    """
1204 
    self.send_startItemOn(item_id, timestamp)
1205 
    self.recv_startItemOn()
1206 
 
1207 
  def send_startItemOn(self, item_id, timestamp):
1208 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1209 
    args = startItemOn_args()
1210 
    args.item_id = item_id
1211 
    args.timestamp = timestamp
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_startItemOn(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = startItemOn_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
1226 
    if result.cex is not None:
1227 
      raise result.cex
1228 
    return
1229 
 
1230 
  def retireItemOn(self, item_id, timestamp):
1231 
    """
1232 
    Parameters:
1233 
     - item_id
1234 
     - timestamp
1235 
    """
1236 
    self.send_retireItemOn(item_id, timestamp)
1237 
    self.recv_retireItemOn()
1238 
 
1239 
  def send_retireItemOn(self, item_id, timestamp):
1240 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1241 
    args = retireItemOn_args()
1242 
    args.item_id = item_id
1243 
    args.timestamp = timestamp
1244 
    args.write(self._oprot)
1245 
    self._oprot.writeMessageEnd()
1246 
    self._oprot.trans.flush()
1247 
 
1248 
  def recv_retireItemOn(self, ):
1249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1250 
    if mtype == TMessageType.EXCEPTION:
1251 
      x = TApplicationException()
1252 
      x.read(self._iprot)
1253 
      self._iprot.readMessageEnd()
1254 
      raise x
1255 
    result = retireItemOn_result()
1256 
    result.read(self._iprot)
1257 
    self._iprot.readMessageEnd()
1258 
    if result.cex is not None:
1259 
      raise result.cex
1260 
    return
1261 
 
1262 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1263 
    """
1264 
    Parameters:
1265 
     - item_id
1266 
     - timestamp
1267 
     - newstatus
1268 
    """
1269 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1270 
    self.recv_changeItemStatus()
1271 
 
1272 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1273 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1274 
    args = changeItemStatus_args()
1275 
    args.item_id = item_id
1276 
    args.timestamp = timestamp
1277 
    args.newstatus = newstatus
1278 
    args.write(self._oprot)
1279 
    self._oprot.writeMessageEnd()
1280 
    self._oprot.trans.flush()
1281 
 
1282 
  def recv_changeItemStatus(self, ):
1283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1284 
    if mtype == TMessageType.EXCEPTION:
1285 
      x = TApplicationException()
1286 
      x.read(self._iprot)
1287 
      self._iprot.readMessageEnd()
1288 
      raise x
1289 
    result = changeItemStatus_result()
1290 
    result.read(self._iprot)
1291 
    self._iprot.readMessageEnd()
1292 
    if result.cex is not None:
1293 
      raise result.cex
1294 
    return
1295 
 
1296 
  def getItem(self, item_id):
1297 
    """
1298 
    Parameters:
1299 
     - item_id
1300 
    """
1301 
    self.send_getItem(item_id)
1302 
    return self.recv_getItem()
1303 
 
1304 
  def send_getItem(self, item_id):
1305 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1306 
    args = getItem_args()
1307 
    args.item_id = item_id
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_getItem(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = getItem_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
1322 
    if result.success is not None:
1323 
      return result.success
1324 
    if result.cex is not None:
1325 
      raise result.cex
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1327 
 
1328 
  def getItemsByCatalogId(self, catalog_item_id):
1329 
    """
1330 
    Parameters:
1331 
     - catalog_item_id
1332 
    """
1333 
    self.send_getItemsByCatalogId(catalog_item_id)
1334 
    return self.recv_getItemsByCatalogId()
1335 
 
1336 
  def send_getItemsByCatalogId(self, catalog_item_id):
1337 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1338 
    args = getItemsByCatalogId_args()
1339 
    args.catalog_item_id = catalog_item_id
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getItemsByCatalogId(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getItemsByCatalogId_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
1354 
    if result.success is not None:
1355 
      return result.success
1356 
    if result.cex is not None:
1357 
      raise result.cex
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1359 
 
1360 
  def getValidItemsByCatalogId(self, catalog_item_id):
1361 
    """
1362 
    Parameters:
1363 
     - catalog_item_id
1364 
    """
1365 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1366 
    return self.recv_getValidItemsByCatalogId()
1367 
 
1368 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1369 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1370 
    args = getValidItemsByCatalogId_args()
1371 
    args.catalog_item_id = catalog_item_id
1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_getValidItemsByCatalogId(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = getValidItemsByCatalogId_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
1386 
    if result.success is not None:
1387 
      return result.success
1388 
    if result.cex is not None:
1389 
      raise result.cex
1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1391 
 
1392 
  def getAllItems(self, isActive):
1393 
    """
1394 
    Parameters:
1395 
     - isActive
1396 
    """
1397 
    self.send_getAllItems(isActive)
1398 
    return self.recv_getAllItems()
1399 
 
1400 
  def send_getAllItems(self, isActive):
1401 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1402 
    args = getAllItems_args()
1403 
    args.isActive = isActive
1404 
    args.write(self._oprot)
1405 
    self._oprot.writeMessageEnd()
1406 
    self._oprot.trans.flush()
1407 
 
1408 
  def recv_getAllItems(self, ):
1409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1410 
    if mtype == TMessageType.EXCEPTION:
1411 
      x = TApplicationException()
1412 
      x.read(self._iprot)
1413 
      self._iprot.readMessageEnd()
1414 
      raise x
1415 
    result = getAllItems_result()
1416 
    result.read(self._iprot)
1417 
    self._iprot.readMessageEnd()
1418 
    if result.success is not None:
1419 
      return result.success
1420 
    if result.cex is not None:
1421 
      raise result.cex
1422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1423 
 
1424 
  def getAllItemsByStatus(self, itemStatus):
1425 
    """
1426 
    Parameters:
1427 
     - itemStatus
1428 
    """
1429 
    self.send_getAllItemsByStatus(itemStatus)
1430 
    return self.recv_getAllItemsByStatus()
1431 
 
1432 
  def send_getAllItemsByStatus(self, itemStatus):
1433 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1434 
    args = getAllItemsByStatus_args()
1435 
    args.itemStatus = itemStatus
1436 
    args.write(self._oprot)
1437 
    self._oprot.writeMessageEnd()
1438 
    self._oprot.trans.flush()
1439 
 
1440 
  def recv_getAllItemsByStatus(self, ):
1441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1442 
    if mtype == TMessageType.EXCEPTION:
1443 
      x = TApplicationException()
1444 
      x.read(self._iprot)
1445 
      self._iprot.readMessageEnd()
1446 
      raise x
1447 
    result = getAllItemsByStatus_result()
1448 
    result.read(self._iprot)
1449 
    self._iprot.readMessageEnd()
1450 
    if result.success is not None:
1451 
      return result.success
1452 
    if result.cex is not None:
1453 
      raise result.cex
1454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1455 
 
9253 rajveer 1456 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1457 
    """
1458 
    Parameters:
1459 
     - entityId
1460 
     - category
1461 
     - brand
1462 
     - modelName
1463 
     - modelNumber
9253 rajveer 1464 
     - isAndroid
5944 mandeep.dh 1465 
    """
9253 rajveer 1466 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1467 
    return self.recv_markItemAsContentComplete()
1468 
 
9253 rajveer 1469 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1470 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1471 
    args = markItemAsContentComplete_args()
1472 
    args.entityId = entityId
1473 
    args.category = category
1474 
    args.brand = brand
1475 
    args.modelName = modelName
1476 
    args.modelNumber = modelNumber
9253 rajveer 1477 
    args.isAndroid = isAndroid
5944 mandeep.dh 1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1482 
  def recv_markItemAsContentComplete(self, ):
1483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1484 
    if mtype == TMessageType.EXCEPTION:
1485 
      x = TApplicationException()
1486 
      x.read(self._iprot)
1487 
      self._iprot.readMessageEnd()
1488 
      raise x
1489 
    result = markItemAsContentComplete_result()
1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
1492 
    if result.success is not None:
1493 
      return result.success
1494 
    if result.cex is not None:
1495 
      raise result.cex
1496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1497 
 
1498 
  def getAllItemsInRange(self, offset, limit):
1499 
    """
1500 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1501 
 
1502 
    Parameters:
1503 
     - offset
1504 
     - limit
1505 
    """
1506 
    self.send_getAllItemsInRange(offset, limit)
1507 
    return self.recv_getAllItemsInRange()
1508 
 
1509 
  def send_getAllItemsInRange(self, offset, limit):
1510 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1511 
    args = getAllItemsInRange_args()
1512 
    args.offset = offset
1513 
    args.limit = limit
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getAllItemsInRange(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getAllItemsInRange_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
1528 
    if result.success is not None:
1529 
      return result.success
1530 
    if result.cex is not None:
1531 
      raise result.cex
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1533 
 
1534 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1535 
    """
1536 
    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.
1537 
 
1538 
    Parameters:
1539 
     - itemStatus
1540 
     - offset
1541 
     - limit
1542 
    """
1543 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1544 
    return self.recv_getAllItemsByStatusInRange()
1545 
 
1546 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1547 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1548 
    args = getAllItemsByStatusInRange_args()
1549 
    args.itemStatus = itemStatus
1550 
    args.offset = offset
1551 
    args.limit = limit
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_getAllItemsByStatusInRange(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = getAllItemsByStatusInRange_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
1566 
    if result.success is not None:
1567 
      return result.success
1568 
    if result.cex is not None:
1569 
      raise result.cex
1570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1571 
 
1572 
  def getItemCountByStatus(self, useStatus, itemStatus):
1573 
    """
1574 
    Gets a count of all items by status
1575 
 
1576 
    Parameters:
1577 
     - useStatus
1578 
     - itemStatus
1579 
    """
1580 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1581 
    return self.recv_getItemCountByStatus()
1582 
 
1583 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1584 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1585 
    args = getItemCountByStatus_args()
1586 
    args.useStatus = useStatus
1587 
    args.itemStatus = itemStatus
1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_getItemCountByStatus(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = getItemCountByStatus_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
1602 
    if result.success is not None:
1603 
      return result.success
1604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1605 
 
1606 
  def getBestSellers(self, ):
1607 
    self.send_getBestSellers()
1608 
    return self.recv_getBestSellers()
1609 
 
1610 
  def send_getBestSellers(self, ):
1611 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1612 
    args = getBestSellers_args()
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getBestSellers(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getBestSellers_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
1627 
    if result.success is not None:
1628 
      return result.success
1629 
    if result.isex is not None:
1630 
      raise result.isex
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1632 
 
1633 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1634 
    """
1635 
    Parameters:
1636 
     - beginIndex
1637 
     - totalItems
1638 
     - brand
1639 
     - category
1640 
    """
1641 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1642 
    return self.recv_getBestSellersCatalogIds()
1643 
 
1644 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1645 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1646 
    args = getBestSellersCatalogIds_args()
1647 
    args.beginIndex = beginIndex
1648 
    args.totalItems = totalItems
1649 
    args.brand = brand
1650 
    args.category = category
1651 
    args.write(self._oprot)
1652 
    self._oprot.writeMessageEnd()
1653 
    self._oprot.trans.flush()
1654 
 
1655 
  def recv_getBestSellersCatalogIds(self, ):
1656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1657 
    if mtype == TMessageType.EXCEPTION:
1658 
      x = TApplicationException()
1659 
      x.read(self._iprot)
1660 
      self._iprot.readMessageEnd()
1661 
      raise x
1662 
    result = getBestSellersCatalogIds_result()
1663 
    result.read(self._iprot)
1664 
    self._iprot.readMessageEnd()
1665 
    if result.success is not None:
1666 
      return result.success
1667 
    if result.cex is not None:
1668 
      raise result.cex
1669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1670 
 
1671 
  def getBestSellersCount(self, ):
1672 
    self.send_getBestSellersCount()
1673 
    return self.recv_getBestSellersCount()
1674 
 
1675 
  def send_getBestSellersCount(self, ):
1676 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1677 
    args = getBestSellersCount_args()
1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
1682 
  def recv_getBestSellersCount(self, ):
1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
1689 
    result = getBestSellersCount_result()
1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
1692 
    if result.success is not None:
1693 
      return result.success
1694 
    if result.cex is not None:
1695 
      raise result.cex
1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1697 
 
1698 
  def getBestDeals(self, ):
1699 
    self.send_getBestDeals()
1700 
    return self.recv_getBestDeals()
1701 
 
1702 
  def send_getBestDeals(self, ):
1703 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1704 
    args = getBestDeals_args()
1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
1709 
  def recv_getBestDeals(self, ):
1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
1716 
    result = getBestDeals_result()
1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
1719 
    if result.success is not None:
1720 
      return result.success
1721 
    if result.isex is not None:
1722 
      raise result.isex
1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1724 
 
1725 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1726 
    """
1727 
    Parameters:
1728 
     - beginIndex
1729 
     - totalItems
1730 
     - brand
1731 
     - category
1732 
    """
1733 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1734 
    return self.recv_getBestDealsCatalogIds()
1735 
 
1736 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1737 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1738 
    args = getBestDealsCatalogIds_args()
1739 
    args.beginIndex = beginIndex
1740 
    args.totalItems = totalItems
1741 
    args.brand = brand
1742 
    args.category = category
1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_getBestDealsCatalogIds(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = getBestDealsCatalogIds_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
1757 
    if result.success is not None:
1758 
      return result.success
1759 
    if result.cex is not None:
1760 
      raise result.cex
1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1762 
 
1763 
  def getBestDealsCount(self, ):
1764 
    self.send_getBestDealsCount()
1765 
    return self.recv_getBestDealsCount()
1766 
 
1767 
  def send_getBestDealsCount(self, ):
1768 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1769 
    args = getBestDealsCount_args()
1770 
    args.write(self._oprot)
1771 
    self._oprot.writeMessageEnd()
1772 
    self._oprot.trans.flush()
1773 
 
1774 
  def recv_getBestDealsCount(self, ):
1775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1776 
    if mtype == TMessageType.EXCEPTION:
1777 
      x = TApplicationException()
1778 
      x.read(self._iprot)
1779 
      self._iprot.readMessageEnd()
1780 
      raise x
1781 
    result = getBestDealsCount_result()
1782 
    result.read(self._iprot)
1783 
    self._iprot.readMessageEnd()
1784 
    if result.success is not None:
1785 
      return result.success
1786 
    if result.cex is not None:
1787 
      raise result.cex
1788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1789 
 
1790 
  def getComingSoon(self, ):
1791 
    self.send_getComingSoon()
1792 
    return self.recv_getComingSoon()
1793 
 
1794 
  def send_getComingSoon(self, ):
1795 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1796 
    args = getComingSoon_args()
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getComingSoon(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getComingSoon_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
1811 
    if result.success is not None:
1812 
      return result.success
1813 
    if result.isex is not None:
1814 
      raise result.isex
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1816 
 
1817 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1818 
    """
1819 
    Parameters:
1820 
     - beginIndex
1821 
     - totalItems
1822 
     - brand
1823 
     - category
1824 
    """
1825 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1826 
    return self.recv_getComingSoonCatalogIds()
1827 
 
1828 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1829 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1830 
    args = getComingSoonCatalogIds_args()
1831 
    args.beginIndex = beginIndex
1832 
    args.totalItems = totalItems
1833 
    args.brand = brand
1834 
    args.category = category
1835 
    args.write(self._oprot)
1836 
    self._oprot.writeMessageEnd()
1837 
    self._oprot.trans.flush()
1838 
 
1839 
  def recv_getComingSoonCatalogIds(self, ):
1840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1841 
    if mtype == TMessageType.EXCEPTION:
1842 
      x = TApplicationException()
1843 
      x.read(self._iprot)
1844 
      self._iprot.readMessageEnd()
1845 
      raise x
1846 
    result = getComingSoonCatalogIds_result()
1847 
    result.read(self._iprot)
1848 
    self._iprot.readMessageEnd()
1849 
    if result.success is not None:
1850 
      return result.success
1851 
    if result.cex is not None:
1852 
      raise result.cex
1853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1854 
 
1855 
  def getComingSoonCount(self, ):
1856 
    self.send_getComingSoonCount()
1857 
    return self.recv_getComingSoonCount()
1858 
 
1859 
  def send_getComingSoonCount(self, ):
1860 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1861 
    args = getComingSoonCount_args()
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_getComingSoonCount(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = getComingSoonCount_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    if result.success is not None:
1877 
      return result.success
1878 
    if result.cex is not None:
1879 
      raise result.cex
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1881 
 
1882 
  def getLatestArrivals(self, ):
1883 
    """
1884 
    Returns a list of items sorted in the descending order by start date.
1885 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1886 
    """
1887 
    self.send_getLatestArrivals()
1888 
    return self.recv_getLatestArrivals()
1889 
 
1890 
  def send_getLatestArrivals(self, ):
1891 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1892 
    args = getLatestArrivals_args()
1893 
    args.write(self._oprot)
1894 
    self._oprot.writeMessageEnd()
1895 
    self._oprot.trans.flush()
1896 
 
1897 
  def recv_getLatestArrivals(self, ):
1898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1899 
    if mtype == TMessageType.EXCEPTION:
1900 
      x = TApplicationException()
1901 
      x.read(self._iprot)
1902 
      self._iprot.readMessageEnd()
1903 
      raise x
1904 
    result = getLatestArrivals_result()
1905 
    result.read(self._iprot)
1906 
    self._iprot.readMessageEnd()
1907 
    if result.success is not None:
1908 
      return result.success
1909 
    if result.isex is not None:
1910 
      raise result.isex
1911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1912 
 
1913 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1914 
    """
1915 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1916 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1917 
 
1918 
    Parameters:
1919 
     - beginIndex
1920 
     - totalItems
1921 
     - brand
1922 
     - categories
1923 
    """
1924 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1925 
    return self.recv_getLatestArrivalsCatalogIds()
1926 
 
1927 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1928 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1929 
    args = getLatestArrivalsCatalogIds_args()
1930 
    args.beginIndex = beginIndex
1931 
    args.totalItems = totalItems
1932 
    args.brand = brand
1933 
    args.categories = categories
1934 
    args.write(self._oprot)
1935 
    self._oprot.writeMessageEnd()
1936 
    self._oprot.trans.flush()
1937 
 
1938 
  def recv_getLatestArrivalsCatalogIds(self, ):
1939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1940 
    if mtype == TMessageType.EXCEPTION:
1941 
      x = TApplicationException()
1942 
      x.read(self._iprot)
1943 
      self._iprot.readMessageEnd()
1944 
      raise x
1945 
    result = getLatestArrivalsCatalogIds_result()
1946 
    result.read(self._iprot)
1947 
    self._iprot.readMessageEnd()
1948 
    if result.success is not None:
1949 
      return result.success
1950 
    if result.cex is not None:
1951 
      raise result.cex
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1953 
 
1954 
  def getLatestArrivalsCount(self, ):
1955 
    """
1956 
    Get the total number of latest arrivals we are willing to show.
1957 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1958 
    """
1959 
    self.send_getLatestArrivalsCount()
1960 
    return self.recv_getLatestArrivalsCount()
1961 
 
1962 
  def send_getLatestArrivalsCount(self, ):
1963 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1964 
    args = getLatestArrivalsCount_args()
1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
1969 
  def recv_getLatestArrivalsCount(self, ):
1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
1976 
    result = getLatestArrivalsCount_result()
1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
1979 
    if result.success is not None:
1980 
      return result.success
1981 
    if result.cex is not None:
1982 
      raise result.cex
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1984 
 
1985 
  def generateNewEntityID(self, ):
1986 
    self.send_generateNewEntityID()
1987 
    return self.recv_generateNewEntityID()
1988 
 
1989 
  def send_generateNewEntityID(self, ):
1990 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1991 
    args = generateNewEntityID_args()
1992 
    args.write(self._oprot)
1993 
    self._oprot.writeMessageEnd()
1994 
    self._oprot.trans.flush()
1995 
 
1996 
  def recv_generateNewEntityID(self, ):
1997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1998 
    if mtype == TMessageType.EXCEPTION:
1999 
      x = TApplicationException()
2000 
      x.read(self._iprot)
2001 
      self._iprot.readMessageEnd()
2002 
      raise x
2003 
    result = generateNewEntityID_result()
2004 
    result.read(self._iprot)
2005 
    self._iprot.readMessageEnd()
2006 
    if result.success is not None:
2007 
      return result.success
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2009 
 
2010 
  def addCategory(self, category):
2011 
    """
2012 
    All category related functions
2013 
 
2014 
    Parameters:
2015 
     - category
2016 
    """
2017 
    self.send_addCategory(category)
2018 
    return self.recv_addCategory()
2019 
 
2020 
  def send_addCategory(self, category):
2021 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2022 
    args = addCategory_args()
2023 
    args.category = category
2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
2028 
  def recv_addCategory(self, ):
2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
2035 
    result = addCategory_result()
2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
2038 
    if result.success is not None:
2039 
      return result.success
2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2041 
 
2042 
  def getCategory(self, id):
2043 
    """
2044 
    Parameters:
2045 
     - id
2046 
    """
2047 
    self.send_getCategory(id)
2048 
    return self.recv_getCategory()
2049 
 
2050 
  def send_getCategory(self, id):
2051 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2052 
    args = getCategory_args()
2053 
    args.id = id
2054 
    args.write(self._oprot)
2055 
    self._oprot.writeMessageEnd()
2056 
    self._oprot.trans.flush()
2057 
 
2058 
  def recv_getCategory(self, ):
2059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2060 
    if mtype == TMessageType.EXCEPTION:
2061 
      x = TApplicationException()
2062 
      x.read(self._iprot)
2063 
      self._iprot.readMessageEnd()
2064 
      raise x
2065 
    result = getCategory_result()
2066 
    result.read(self._iprot)
2067 
    self._iprot.readMessageEnd()
2068 
    if result.success is not None:
2069 
      return result.success
2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2071 
 
2072 
  def getAllCategories(self, ):
2073 
    self.send_getAllCategories()
2074 
    return self.recv_getAllCategories()
2075 
 
2076 
  def send_getAllCategories(self, ):
2077 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2078 
    args = getAllCategories_args()
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_getAllCategories(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = getAllCategories_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
2093 
    if result.success is not None:
2094 
      return result.success
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2096 
 
2097 
  def getAllSimilarItems(self, itemId):
2098 
    """
2099 
    Returns the list of similar items.
2100 
 
2101 
    Parameters:
2102 
     - itemId
2103 
    """
2104 
    self.send_getAllSimilarItems(itemId)
2105 
    return self.recv_getAllSimilarItems()
2106 
 
2107 
  def send_getAllSimilarItems(self, itemId):
2108 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2109 
    args = getAllSimilarItems_args()
2110 
    args.itemId = itemId
2111 
    args.write(self._oprot)
2112 
    self._oprot.writeMessageEnd()
2113 
    self._oprot.trans.flush()
2114 
 
2115 
  def recv_getAllSimilarItems(self, ):
2116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2117 
    if mtype == TMessageType.EXCEPTION:
2118 
      x = TApplicationException()
2119 
      x.read(self._iprot)
2120 
      self._iprot.readMessageEnd()
2121 
      raise x
2122 
    result = getAllSimilarItems_result()
2123 
    result.read(self._iprot)
2124 
    self._iprot.readMessageEnd()
2125 
    if result.success is not None:
2126 
      return result.success
2127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2128 
 
2129 
  def addSimilarItem(self, itemId, catalogItemId):
2130 
    """
2131 
    Adds similar item.
2132 
 
2133 
    Parameters:
2134 
     - itemId
2135 
     - catalogItemId
2136 
    """
2137 
    self.send_addSimilarItem(itemId, catalogItemId)
2138 
    return self.recv_addSimilarItem()
2139 
 
2140 
  def send_addSimilarItem(self, itemId, catalogItemId):
2141 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2142 
    args = addSimilarItem_args()
2143 
    args.itemId = itemId
2144 
    args.catalogItemId = catalogItemId
2145 
    args.write(self._oprot)
2146 
    self._oprot.writeMessageEnd()
2147 
    self._oprot.trans.flush()
2148 
 
2149 
  def recv_addSimilarItem(self, ):
2150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2151 
    if mtype == TMessageType.EXCEPTION:
2152 
      x = TApplicationException()
2153 
      x.read(self._iprot)
2154 
      self._iprot.readMessageEnd()
2155 
      raise x
2156 
    result = addSimilarItem_result()
2157 
    result.read(self._iprot)
2158 
    self._iprot.readMessageEnd()
2159 
    if result.success is not None:
2160 
      return result.success
2161 
    if result.cex is not None:
2162 
      raise result.cex
2163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2164 
 
6512 kshitij.so 2165 
  def addTag(self, displayName, itemId):
2166 
    """
2167 
    Tag Related
2168 
 
2169 
    Parameters:
2170 
     - displayName
2171 
     - itemId
2172 
    """
2173 
    self.send_addTag(displayName, itemId)
2174 
    return self.recv_addTag()
2175 
 
2176 
  def send_addTag(self, displayName, itemId):
2177 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2178 
    args = addTag_args()
2179 
    args.displayName = displayName
2180 
    args.itemId = itemId
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_addTag(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = addTag_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
2195 
    if result.success is not None:
2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2198 
 
2199 
  def deleteEntityTag(self, displayName, itemId):
2200 
    """
2201 
    Parameters:
2202 
     - displayName
2203 
     - itemId
2204 
    """
2205 
    self.send_deleteEntityTag(displayName, itemId)
2206 
    return self.recv_deleteEntityTag()
2207 
 
2208 
  def send_deleteEntityTag(self, displayName, itemId):
2209 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2210 
    args = deleteEntityTag_args()
2211 
    args.displayName = displayName
2212 
    args.itemId = itemId
2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_deleteEntityTag(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = deleteEntityTag_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.success is not None:
2228 
      return result.success
2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2230 
 
2231 
  def deleteTag(self, displayName):
2232 
    """
2233 
    Parameters:
2234 
     - displayName
2235 
    """
2236 
    self.send_deleteTag(displayName)
2237 
    return self.recv_deleteTag()
2238 
 
2239 
  def send_deleteTag(self, displayName):
2240 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2241 
    args = deleteTag_args()
2242 
    args.displayName = displayName
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
2247 
  def recv_deleteTag(self, ):
2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
2254 
    result = deleteTag_result()
2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
2257 
    if result.success is not None:
2258 
      return result.success
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2260 
 
2261 
  def getAllTags(self, ):
2262 
    self.send_getAllTags()
2263 
    return self.recv_getAllTags()
2264 
 
2265 
  def send_getAllTags(self, ):
2266 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2267 
    args = getAllTags_args()
2268 
    args.write(self._oprot)
2269 
    self._oprot.writeMessageEnd()
2270 
    self._oprot.trans.flush()
2271 
 
2272 
  def recv_getAllTags(self, ):
2273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2274 
    if mtype == TMessageType.EXCEPTION:
2275 
      x = TApplicationException()
2276 
      x.read(self._iprot)
2277 
      self._iprot.readMessageEnd()
2278 
      raise x
2279 
    result = getAllTags_result()
2280 
    result.read(self._iprot)
2281 
    self._iprot.readMessageEnd()
2282 
    if result.success is not None:
2283 
      return result.success
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2285 
 
2286 
  def getAllEntitiesByTagName(self, displayName):
2287 
    """
2288 
    Parameters:
2289 
     - displayName
2290 
    """
2291 
    self.send_getAllEntitiesByTagName(displayName)
2292 
    return self.recv_getAllEntitiesByTagName()
2293 
 
2294 
  def send_getAllEntitiesByTagName(self, displayName):
2295 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2296 
    args = getAllEntitiesByTagName_args()
2297 
    args.displayName = displayName
2298 
    args.write(self._oprot)
2299 
    self._oprot.writeMessageEnd()
2300 
    self._oprot.trans.flush()
2301 
 
2302 
  def recv_getAllEntitiesByTagName(self, ):
2303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2304 
    if mtype == TMessageType.EXCEPTION:
2305 
      x = TApplicationException()
2306 
      x.read(self._iprot)
2307 
      self._iprot.readMessageEnd()
2308 
      raise x
2309 
    result = getAllEntitiesByTagName_result()
2310 
    result.read(self._iprot)
2311 
    self._iprot.readMessageEnd()
2312 
    if result.success is not None:
2313 
      return result.success
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2315 
 
6845 amit.gupta 2316 
  def getAllEntityTags(self, ):
2317 
    self.send_getAllEntityTags()
2318 
    return self.recv_getAllEntityTags()
2319 
 
2320 
  def send_getAllEntityTags(self, ):
2321 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2322 
    args = getAllEntityTags_args()
2323 
    args.write(self._oprot)
2324 
    self._oprot.writeMessageEnd()
2325 
    self._oprot.trans.flush()
2326 
 
2327 
  def recv_getAllEntityTags(self, ):
2328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2329 
    if mtype == TMessageType.EXCEPTION:
2330 
      x = TApplicationException()
2331 
      x.read(self._iprot)
2332 
      self._iprot.readMessageEnd()
2333 
      raise x
2334 
    result = getAllEntityTags_result()
2335 
    result.read(self._iprot)
2336 
    self._iprot.readMessageEnd()
2337 
    if result.success is not None:
2338 
      return result.success
2339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2340 
 
8590 kshitij.so 2341 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2342 
    """
8579 kshitij.so 2343 
    Banner Related
2344 
 
6850 kshitij.so 2345 
    Parameters:
8590 kshitij.so 2346 
     - bannerCongregate
6850 kshitij.so 2347 
    """
8590 kshitij.so 2348 
    self.send_addBanner(bannerCongregate)
2349 
    self.recv_addBanner()
6850 kshitij.so 2350 
 
8590 kshitij.so 2351 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2352 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2353 
    args = addBanner_args()
8590 kshitij.so 2354 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2355 
    args.write(self._oprot)
2356 
    self._oprot.writeMessageEnd()
2357 
    self._oprot.trans.flush()
2358 
 
2359 
  def recv_addBanner(self, ):
2360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2361 
    if mtype == TMessageType.EXCEPTION:
2362 
      x = TApplicationException()
2363 
      x.read(self._iprot)
2364 
      self._iprot.readMessageEnd()
2365 
      raise x
2366 
    result = addBanner_result()
2367 
    result.read(self._iprot)
2368 
    self._iprot.readMessageEnd()
8590 kshitij.so 2369 
    return
6850 kshitij.so 2370 
 
8579 kshitij.so 2371 
  def updateBanner(self, banner):
2372 
    """
2373 
    Parameters:
2374 
     - banner
2375 
    """
2376 
    self.send_updateBanner(banner)
2377 
    return self.recv_updateBanner()
2378 
 
2379 
  def send_updateBanner(self, banner):
2380 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2381 
    args = updateBanner_args()
2382 
    args.banner = banner
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_updateBanner(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = updateBanner_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    if result.success is not None:
2398 
      return result.success
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2400 
 
6850 kshitij.so 2401 
  def getAllBanners(self, ):
2402 
    self.send_getAllBanners()
2403 
    return self.recv_getAllBanners()
2404 
 
2405 
  def send_getAllBanners(self, ):
2406 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2407 
    args = getAllBanners_args()
2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_getAllBanners(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = getAllBanners_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
2422 
    if result.success is not None:
2423 
      return result.success
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2425 
 
9155 kshitij.so 2426 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2427 
    """
2428 
    Parameters:
2429 
     - bannerName
9155 kshitij.so 2430 
     - bannerType
6850 kshitij.so 2431 
    """
9155 kshitij.so 2432 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2433 
    return self.recv_deleteBanner()
2434 
 
9155 kshitij.so 2435 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2436 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2437 
    args = deleteBanner_args()
2438 
    args.bannerName = bannerName
9155 kshitij.so 2439 
    args.bannerType = bannerType
6850 kshitij.so 2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
2444 
  def recv_deleteBanner(self, ):
2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
2451 
    result = deleteBanner_result()
2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
2454 
    if result.success is not None:
2455 
      return result.success
2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2457 
 
9155 kshitij.so 2458 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2459 
    """
2460 
    Parameters:
2461 
     - bannerName
9155 kshitij.so 2462 
     - bannerType
6850 kshitij.so 2463 
    """
9155 kshitij.so 2464 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2465 
    return self.recv_getBannerDetails()
2466 
 
9155 kshitij.so 2467 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2468 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2469 
    args = getBannerDetails_args()
2470 
    args.bannerName = bannerName
9155 kshitij.so 2471 
    args.bannerType = bannerType
6850 kshitij.so 2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
2476 
  def recv_getBannerDetails(self, ):
2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
2483 
    result = getBannerDetails_result()
2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
2486 
    if result.success is not None:
2487 
      return result.success
2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2489 
 
2490 
  def getActiveBanners(self, ):
2491 
    self.send_getActiveBanners()
2492 
    return self.recv_getActiveBanners()
2493 
 
2494 
  def send_getActiveBanners(self, ):
2495 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2496 
    args = getActiveBanners_args()
2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_getActiveBanners(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = getActiveBanners_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
2511 
    if result.success is not None:
2512 
      return result.success
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2514 
 
8579 kshitij.so 2515 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2516 
    """
2517 
    Parameters:
8579 kshitij.so 2518 
     - bannerMaps
6849 kshitij.so 2519 
    """
8579 kshitij.so 2520 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2521 
    return self.recv_addBannerMap()
2522 
 
8579 kshitij.so 2523 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2524 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2525 
    args = addBannerMap_args()
8579 kshitij.so 2526 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2527 
    args.write(self._oprot)
2528 
    self._oprot.writeMessageEnd()
2529 
    self._oprot.trans.flush()
2530 
 
2531 
  def recv_addBannerMap(self, ):
2532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2533 
    if mtype == TMessageType.EXCEPTION:
2534 
      x = TApplicationException()
2535 
      x.read(self._iprot)
2536 
      self._iprot.readMessageEnd()
2537 
      raise x
2538 
    result = addBannerMap_result()
2539 
    result.read(self._iprot)
2540 
    self._iprot.readMessageEnd()
2541 
    if result.success is not None:
2542 
      return result.success
2543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2544 
 
8579 kshitij.so 2545 
  def updateBannerMap(self, bannerMap):
2546 
    """
2547 
    Parameters:
2548 
     - bannerMap
2549 
    """
2550 
    self.send_updateBannerMap(bannerMap)
2551 
    return self.recv_updateBannerMap()
2552 
 
2553 
  def send_updateBannerMap(self, bannerMap):
2554 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2555 
    args = updateBannerMap_args()
2556 
    args.bannerMap = bannerMap
2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
2561 
  def recv_updateBannerMap(self, ):
2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
2568 
    result = updateBannerMap_result()
2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
2571 
    if result.success is not None:
2572 
      return result.success
2573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2574 
 
6849 kshitij.so 2575 
  def deleteBannerMap(self, bannerName):
2576 
    """
2577 
    Parameters:
2578 
     - bannerName
2579 
    """
2580 
    self.send_deleteBannerMap(bannerName)
2581 
    return self.recv_deleteBannerMap()
2582 
 
2583 
  def send_deleteBannerMap(self, bannerName):
2584 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2585 
    args = deleteBannerMap_args()
2586 
    args.bannerName = bannerName
2587 
    args.write(self._oprot)
2588 
    self._oprot.writeMessageEnd()
2589 
    self._oprot.trans.flush()
2590 
 
2591 
  def recv_deleteBannerMap(self, ):
2592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2593 
    if mtype == TMessageType.EXCEPTION:
2594 
      x = TApplicationException()
2595 
      x.read(self._iprot)
2596 
      self._iprot.readMessageEnd()
2597 
      raise x
2598 
    result = deleteBannerMap_result()
2599 
    result.read(self._iprot)
2600 
    self._iprot.readMessageEnd()
2601 
    if result.success is not None:
2602 
      return result.success
2603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2604 
 
9155 kshitij.so 2605 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2606 
    """
2607 
    Parameters:
2608 
     - bannerName
9155 kshitij.so 2609 
     - bannerType
6849 kshitij.so 2610 
    """
9155 kshitij.so 2611 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2612 
    return self.recv_getBannerMapDetails()
2613 
 
9155 kshitij.so 2614 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2615 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2616 
    args = getBannerMapDetails_args()
2617 
    args.bannerName = bannerName
9155 kshitij.so 2618 
    args.bannerType = bannerType
6849 kshitij.so 2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_getBannerMapDetails(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = getBannerMapDetails_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    if result.success is not None:
2634 
      return result.success
2635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2636 
 
8579 kshitij.so 2637 
  def addBannerUri(self, bannerUriMappings):
2638 
    """
2639 
    Parameters:
2640 
     - bannerUriMappings
2641 
    """
2642 
    self.send_addBannerUri(bannerUriMappings)
2643 
    self.recv_addBannerUri()
2644 
 
2645 
  def send_addBannerUri(self, bannerUriMappings):
2646 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2647 
    args = addBannerUri_args()
2648 
    args.bannerUriMappings = bannerUriMappings
2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
2653 
  def recv_addBannerUri(self, ):
2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
2660 
    result = addBannerUri_result()
2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
2663 
    return
2664 
 
9155 kshitij.so 2665 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2666 
    """
2667 
    Parameters:
2668 
     - bannerName
9155 kshitij.so 2669 
     - bannerType
8579 kshitij.so 2670 
    """
9155 kshitij.so 2671 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2672 
    return self.recv_getUriMapping()
2673 
 
9155 kshitij.so 2674 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2675 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2676 
    args = getUriMapping_args()
2677 
    args.bannerName = bannerName
9155 kshitij.so 2678 
    args.bannerType = bannerType
8579 kshitij.so 2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_getUriMapping(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = getUriMapping_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2696 
 
2697 
  def addCampaign(self, campaign):
2698 
    """
2699 
    Parameters:
2700 
     - campaign
2701 
    """
2702 
    self.send_addCampaign(campaign)
2703 
    self.recv_addCampaign()
2704 
 
2705 
  def send_addCampaign(self, campaign):
2706 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2707 
    args = addCampaign_args()
2708 
    args.campaign = campaign
2709 
    args.write(self._oprot)
2710 
    self._oprot.writeMessageEnd()
2711 
    self._oprot.trans.flush()
2712 
 
2713 
  def recv_addCampaign(self, ):
2714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2715 
    if mtype == TMessageType.EXCEPTION:
2716 
      x = TApplicationException()
2717 
      x.read(self._iprot)
2718 
      self._iprot.readMessageEnd()
2719 
      raise x
2720 
    result = addCampaign_result()
2721 
    result.read(self._iprot)
2722 
    self._iprot.readMessageEnd()
2723 
    return
2724 
 
2725 
  def getCampaigns(self, campaignName):
2726 
    """
2727 
    Parameters:
2728 
     - campaignName
2729 
    """
2730 
    self.send_getCampaigns(campaignName)
2731 
    return self.recv_getCampaigns()
2732 
 
2733 
  def send_getCampaigns(self, campaignName):
2734 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2735 
    args = getCampaigns_args()
2736 
    args.campaignName = campaignName
2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_getCampaigns(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = getCampaigns_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    if result.success is not None:
2752 
      return result.success
2753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2754 
 
2755 
  def deleteCampaign(self, campaignId):
2756 
    """
2757 
    Parameters:
2758 
     - campaignId
2759 
    """
2760 
    self.send_deleteCampaign(campaignId)
2761 
    self.recv_deleteCampaign()
2762 
 
2763 
  def send_deleteCampaign(self, campaignId):
2764 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2765 
    args = deleteCampaign_args()
2766 
    args.campaignId = campaignId
2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_deleteCampaign(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = deleteCampaign_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
2781 
    return
2782 
 
2783 
  def getAllCampaigns(self, ):
2784 
    self.send_getAllCampaigns()
2785 
    return self.recv_getAllCampaigns()
2786 
 
2787 
  def send_getAllCampaigns(self, ):
2788 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2789 
    args = getAllCampaigns_args()
2790 
    args.write(self._oprot)
2791 
    self._oprot.writeMessageEnd()
2792 
    self._oprot.trans.flush()
2793 
 
2794 
  def recv_getAllCampaigns(self, ):
2795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2796 
    if mtype == TMessageType.EXCEPTION:
2797 
      x = TApplicationException()
2798 
      x.read(self._iprot)
2799 
      self._iprot.readMessageEnd()
2800 
      raise x
2801 
    result = getAllCampaigns_result()
2802 
    result.read(self._iprot)
2803 
    self._iprot.readMessageEnd()
2804 
    if result.success is not None:
2805 
      return result.success
2806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2807 
 
9155 kshitij.so 2808 
  def getActiveBannersForMobileSite(self, ):
2809 
    self.send_getActiveBannersForMobileSite()
2810 
    return self.recv_getActiveBannersForMobileSite()
2811 
 
2812 
  def send_getActiveBannersForMobileSite(self, ):
2813 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2814 
    args = getActiveBannersForMobileSite_args()
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_getActiveBannersForMobileSite(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = getActiveBannersForMobileSite_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
2829 
    if result.success is not None:
2830 
      return result.success
2831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2832 
 
5944 mandeep.dh 2833 
  def deleteSimilarItem(self, itemId, catalogItemId):
2834 
    """
2835 
    Delete similar item.
2836 
 
2837 
    Parameters:
2838 
     - itemId
2839 
     - catalogItemId
2840 
    """
2841 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2842 
    return self.recv_deleteSimilarItem()
2843 
 
2844 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2845 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2846 
    args = deleteSimilarItem_args()
2847 
    args.itemId = itemId
2848 
    args.catalogItemId = catalogItemId
2849 
    args.write(self._oprot)
2850 
    self._oprot.writeMessageEnd()
2851 
    self._oprot.trans.flush()
2852 
 
2853 
  def recv_deleteSimilarItem(self, ):
2854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2855 
    if mtype == TMessageType.EXCEPTION:
2856 
      x = TApplicationException()
2857 
      x.read(self._iprot)
2858 
      self._iprot.readMessageEnd()
2859 
      raise x
2860 
    result = deleteSimilarItem_result()
2861 
    result.read(self._iprot)
2862 
    self._iprot.readMessageEnd()
2863 
    if result.success is not None:
2864 
      return result.success
2865 
    if result.cex is not None:
2866 
      raise result.cex
2867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2868 
 
2869 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2870 
    """
2871 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2872 
    If yes, returns the itemId else returns 0
2873 
 
2874 
    Parameters:
2875 
     - brand
2876 
     - modelNumber
2877 
     - modelName
2878 
     - color
2879 
    """
2880 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2881 
    return self.recv_checkSimilarItem()
2882 
 
2883 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2884 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2885 
    args = checkSimilarItem_args()
2886 
    args.brand = brand
2887 
    args.modelNumber = modelNumber
2888 
    args.modelName = modelName
2889 
    args.color = color
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_checkSimilarItem(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = checkSimilarItem_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
2904 
    if result.success is not None:
2905 
      return result.success
2906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2907 
 
2908 
  def validateRiskyStatus(self, itemId):
2909 
    """
2910 
    Check wether item is risky and change status if inventory is not available for risky items
2911 
 
2912 
    Parameters:
2913 
     - itemId
2914 
    """
2915 
    self.send_validateRiskyStatus(itemId)
2916 
    self.recv_validateRiskyStatus()
2917 
 
2918 
  def send_validateRiskyStatus(self, itemId):
2919 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2920 
    args = validateRiskyStatus_args()
2921 
    args.itemId = itemId
2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
2926 
  def recv_validateRiskyStatus(self, ):
2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
2933 
    result = validateRiskyStatus_result()
2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
2936 
    return
2937 
 
2938 
  def changeItemRiskyFlag(self, itemId, risky):
2939 
    """
2940 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2941 
 
2942 
    Parameters:
2943 
     - itemId
2944 
     - risky
2945 
    """
2946 
    self.send_changeItemRiskyFlag(itemId, risky)
2947 
    self.recv_changeItemRiskyFlag()
2948 
 
2949 
  def send_changeItemRiskyFlag(self, itemId, risky):
2950 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2951 
    args = changeItemRiskyFlag_args()
2952 
    args.itemId = itemId
2953 
    args.risky = risky
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_changeItemRiskyFlag(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = changeItemRiskyFlag_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    return
2969 
 
2970 
  def getItemsByRiskyFlag(self, ):
2971 
    """
2972 
    Returns list of items marked as risky.
2973 
    """
2974 
    self.send_getItemsByRiskyFlag()
2975 
    return self.recv_getItemsByRiskyFlag()
2976 
 
2977 
  def send_getItemsByRiskyFlag(self, ):
2978 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2979 
    args = getItemsByRiskyFlag_args()
2980 
    args.write(self._oprot)
2981 
    self._oprot.writeMessageEnd()
2982 
    self._oprot.trans.flush()
2983 
 
2984 
  def recv_getItemsByRiskyFlag(self, ):
2985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2986 
    if mtype == TMessageType.EXCEPTION:
2987 
      x = TApplicationException()
2988 
      x.read(self._iprot)
2989 
      self._iprot.readMessageEnd()
2990 
      raise x
2991 
    result = getItemsByRiskyFlag_result()
2992 
    result.read(self._iprot)
2993 
    self._iprot.readMessageEnd()
2994 
    if result.success is not None:
2995 
      return result.success
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2997 
 
2998 
  def getItemsForMasterSheet(self, category, brand):
2999 
    """
3000 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3001 
 
3002 
    Parameters:
3003 
     - category
3004 
     - brand
3005 
    """
3006 
    self.send_getItemsForMasterSheet(category, brand)
3007 
    return self.recv_getItemsForMasterSheet()
3008 
 
3009 
  def send_getItemsForMasterSheet(self, category, brand):
3010 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3011 
    args = getItemsForMasterSheet_args()
3012 
    args.category = category
3013 
    args.brand = brand
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_getItemsForMasterSheet(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = getItemsForMasterSheet_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3028 
    if result.success is not None:
3029 
      return result.success
3030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3031 
 
3032 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3033 
    """
3034 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3035 
 
3036 
    Parameters:
3037 
     - beginIndex
3038 
     - totalItems
3039 
     - itemId
3040 
    """
3041 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3042 
    return self.recv_getSimilarItemsCatalogIds()
3043 
 
3044 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3045 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3046 
    args = getSimilarItemsCatalogIds_args()
3047 
    args.beginIndex = beginIndex
3048 
    args.totalItems = totalItems
3049 
    args.itemId = itemId
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_getSimilarItemsCatalogIds(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = getSimilarItemsCatalogIds_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.success is not None:
3065 
      return result.success
3066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3067 
 
3068 
  def addProductNotification(self, itemId, email):
3069 
    """
3070 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3071 
 
3072 
    Parameters:
3073 
     - itemId
3074 
     - email
3075 
    """
3076 
    self.send_addProductNotification(itemId, email)
3077 
    return self.recv_addProductNotification()
3078 
 
3079 
  def send_addProductNotification(self, itemId, email):
3080 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3081 
    args = addProductNotification_args()
3082 
    args.itemId = itemId
3083 
    args.email = email
3084 
    args.write(self._oprot)
3085 
    self._oprot.writeMessageEnd()
3086 
    self._oprot.trans.flush()
3087 
 
3088 
  def recv_addProductNotification(self, ):
3089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3090 
    if mtype == TMessageType.EXCEPTION:
3091 
      x = TApplicationException()
3092 
      x.read(self._iprot)
3093 
      self._iprot.readMessageEnd()
3094 
      raise x
3095 
    result = addProductNotification_result()
3096 
    result.read(self._iprot)
3097 
    self._iprot.readMessageEnd()
3098 
    if result.success is not None:
3099 
      return result.success
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3101 
 
3102 
  def sendProductNotifications(self, ):
3103 
    """
3104 
    Send the product notifications to the users for items which has stock.
3105 
    """
3106 
    self.send_sendProductNotifications()
3107 
    return self.recv_sendProductNotifications()
3108 
 
3109 
  def send_sendProductNotifications(self, ):
3110 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3111 
    args = sendProductNotifications_args()
3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_sendProductNotifications(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = sendProductNotifications_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3126 
    if result.success is not None:
3127 
      return result.success
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3129 
 
3130 
  def getAllBrandsByCategory(self, categoryId):
3131 
    """
3132 
    Returns list of brand names for a given category Id
3133 
 
3134 
    Parameters:
3135 
     - categoryId
3136 
    """
3137 
    self.send_getAllBrandsByCategory(categoryId)
3138 
    return self.recv_getAllBrandsByCategory()
3139 
 
3140 
  def send_getAllBrandsByCategory(self, categoryId):
3141 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3142 
    args = getAllBrandsByCategory_args()
3143 
    args.categoryId = categoryId
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_getAllBrandsByCategory(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = getAllBrandsByCategory_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
3160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3161 
 
3162 
  def getAllBrands(self, ):
3163 
    """
3164 
    Returns list of brand names
3165 
    """
3166 
    self.send_getAllBrands()
3167 
    return self.recv_getAllBrands()
3168 
 
3169 
  def send_getAllBrands(self, ):
3170 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3171 
    args = getAllBrands_args()
3172 
    args.write(self._oprot)
3173 
    self._oprot.writeMessageEnd()
3174 
    self._oprot.trans.flush()
3175 
 
3176 
  def recv_getAllBrands(self, ):
3177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3178 
    if mtype == TMessageType.EXCEPTION:
3179 
      x = TApplicationException()
3180 
      x.read(self._iprot)
3181 
      self._iprot.readMessageEnd()
3182 
      raise x
3183 
    result = getAllBrands_result()
3184 
    result.read(self._iprot)
3185 
    self._iprot.readMessageEnd()
3186 
    if result.success is not None:
3187 
      return result.success
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3189 
 
3190 
  def getAllSources(self, ):
3191 
    """
3192 
    Return list of all sources
3193 
    """
3194 
    self.send_getAllSources()
3195 
    return self.recv_getAllSources()
3196 
 
3197 
  def send_getAllSources(self, ):
3198 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3199 
    args = getAllSources_args()
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
3204 
  def recv_getAllSources(self, ):
3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
3211 
    result = getAllSources_result()
3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3214 
    if result.success is not None:
3215 
      return result.success
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3217 
 
3218 
  def getItemPricingBySource(self, itemId, sourceId):
3219 
    """
3220 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3221 
 
3222 
    Parameters:
3223 
     - itemId
3224 
     - sourceId
3225 
    """
3226 
    self.send_getItemPricingBySource(itemId, sourceId)
3227 
    return self.recv_getItemPricingBySource()
3228 
 
3229 
  def send_getItemPricingBySource(self, itemId, sourceId):
3230 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3231 
    args = getItemPricingBySource_args()
3232 
    args.itemId = itemId
3233 
    args.sourceId = sourceId
3234 
    args.write(self._oprot)
3235 
    self._oprot.writeMessageEnd()
3236 
    self._oprot.trans.flush()
3237 
 
3238 
  def recv_getItemPricingBySource(self, ):
3239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3240 
    if mtype == TMessageType.EXCEPTION:
3241 
      x = TApplicationException()
3242 
      x.read(self._iprot)
3243 
      self._iprot.readMessageEnd()
3244 
      raise x
3245 
    result = getItemPricingBySource_result()
3246 
    result.read(self._iprot)
3247 
    self._iprot.readMessageEnd()
3248 
    if result.success is not None:
3249 
      return result.success
3250 
    if result.cex is not None:
3251 
      raise result.cex
3252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3253 
 
3254 
  def addSourceItemPricing(self, sourceItemPricing):
3255 
    """
3256 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3257 
    If item is not found or source is not found, it will throw exception.
3258 
 
3259 
    Parameters:
3260 
     - sourceItemPricing
3261 
    """
3262 
    self.send_addSourceItemPricing(sourceItemPricing)
3263 
    self.recv_addSourceItemPricing()
3264 
 
3265 
  def send_addSourceItemPricing(self, sourceItemPricing):
3266 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3267 
    args = addSourceItemPricing_args()
3268 
    args.sourceItemPricing = sourceItemPricing
3269 
    args.write(self._oprot)
3270 
    self._oprot.writeMessageEnd()
3271 
    self._oprot.trans.flush()
3272 
 
3273 
  def recv_addSourceItemPricing(self, ):
3274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3275 
    if mtype == TMessageType.EXCEPTION:
3276 
      x = TApplicationException()
3277 
      x.read(self._iprot)
3278 
      self._iprot.readMessageEnd()
3279 
      raise x
3280 
    result = addSourceItemPricing_result()
3281 
    result.read(self._iprot)
3282 
    self._iprot.readMessageEnd()
3283 
    if result.cex is not None:
3284 
      raise result.cex
3285 
    return
3286 
 
3287 
  def getAllSourcePricing(self, itemId):
3288 
    """
3289 
    Returns the list of source pricing information of an item.
3290 
    Raises an exception if item not found corresponding to itemId
3291 
 
3292 
    Parameters:
3293 
     - itemId
3294 
    """
3295 
    self.send_getAllSourcePricing(itemId)
3296 
    return self.recv_getAllSourcePricing()
3297 
 
3298 
  def send_getAllSourcePricing(self, itemId):
3299 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3300 
    args = getAllSourcePricing_args()
3301 
    args.itemId = itemId
3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
3306 
  def recv_getAllSourcePricing(self, ):
3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
3313 
    result = getAllSourcePricing_result()
3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3316 
    if result.success is not None:
3317 
      return result.success
3318 
    if result.cex is not None:
3319 
      raise result.cex
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3321 
 
3322 
  def getItemForSource(self, item_id, sourceId):
3323 
    """
3324 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3325 
 
3326 
    Parameters:
3327 
     - item_id
3328 
     - sourceId
3329 
    """
3330 
    self.send_getItemForSource(item_id, sourceId)
3331 
    return self.recv_getItemForSource()
3332 
 
3333 
  def send_getItemForSource(self, item_id, sourceId):
3334 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3335 
    args = getItemForSource_args()
3336 
    args.item_id = item_id
3337 
    args.sourceId = sourceId
3338 
    args.write(self._oprot)
3339 
    self._oprot.writeMessageEnd()
3340 
    self._oprot.trans.flush()
3341 
 
3342 
  def recv_getItemForSource(self, ):
3343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3344 
    if mtype == TMessageType.EXCEPTION:
3345 
      x = TApplicationException()
3346 
      x.read(self._iprot)
3347 
      self._iprot.readMessageEnd()
3348 
      raise x
3349 
    result = getItemForSource_result()
3350 
    result.read(self._iprot)
3351 
    self._iprot.readMessageEnd()
3352 
    if result.success is not None:
3353 
      return result.success
3354 
    if result.cex is not None:
3355 
      raise result.cex
3356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3357 
 
3358 
  def searchItemsInRange(self, searchTerms, offset, limit):
3359 
    """
3360 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3361 
 
3362 
    Parameters:
3363 
     - searchTerms
3364 
     - offset
3365 
     - limit
3366 
    """
3367 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3368 
    return self.recv_searchItemsInRange()
3369 
 
3370 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3371 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3372 
    args = searchItemsInRange_args()
3373 
    args.searchTerms = searchTerms
3374 
    args.offset = offset
3375 
    args.limit = limit
3376 
    args.write(self._oprot)
3377 
    self._oprot.writeMessageEnd()
3378 
    self._oprot.trans.flush()
3379 
 
3380 
  def recv_searchItemsInRange(self, ):
3381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3382 
    if mtype == TMessageType.EXCEPTION:
3383 
      x = TApplicationException()
3384 
      x.read(self._iprot)
3385 
      self._iprot.readMessageEnd()
3386 
      raise x
3387 
    result = searchItemsInRange_result()
3388 
    result.read(self._iprot)
3389 
    self._iprot.readMessageEnd()
3390 
    if result.success is not None:
3391 
      return result.success
3392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3393 
 
3394 
  def getSearchResultCount(self, searchTerms):
3395 
    """
3396 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3397 
 
3398 
    Parameters:
3399 
     - searchTerms
3400 
    """
3401 
    self.send_getSearchResultCount(searchTerms)
3402 
    return self.recv_getSearchResultCount()
3403 
 
3404 
  def send_getSearchResultCount(self, searchTerms):
3405 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3406 
    args = getSearchResultCount_args()
3407 
    args.searchTerms = searchTerms
3408 
    args.write(self._oprot)
3409 
    self._oprot.writeMessageEnd()
3410 
    self._oprot.trans.flush()
3411 
 
3412 
  def recv_getSearchResultCount(self, ):
3413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3414 
    if mtype == TMessageType.EXCEPTION:
3415 
      x = TApplicationException()
3416 
      x.read(self._iprot)
3417 
      self._iprot.readMessageEnd()
3418 
      raise x
3419 
    result = getSearchResultCount_result()
3420 
    result.read(self._iprot)
3421 
    self._iprot.readMessageEnd()
3422 
    if result.success is not None:
3423 
      return result.success
3424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3425 
 
3426 
  def getProductNotifications(self, startDateTime):
3427 
    """
3428 
    Returns a list of product notifications added after a supplied datetime
3429 
 
3430 
    Parameters:
3431 
     - startDateTime
3432 
    """
3433 
    self.send_getProductNotifications(startDateTime)
3434 
    return self.recv_getProductNotifications()
3435 
 
3436 
  def send_getProductNotifications(self, startDateTime):
3437 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3438 
    args = getProductNotifications_args()
3439 
    args.startDateTime = startDateTime
3440 
    args.write(self._oprot)
3441 
    self._oprot.writeMessageEnd()
3442 
    self._oprot.trans.flush()
3443 
 
3444 
  def recv_getProductNotifications(self, ):
3445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3446 
    if mtype == TMessageType.EXCEPTION:
3447 
      x = TApplicationException()
3448 
      x.read(self._iprot)
3449 
      self._iprot.readMessageEnd()
3450 
      raise x
3451 
    result = getProductNotifications_result()
3452 
    result.read(self._iprot)
3453 
    self._iprot.readMessageEnd()
3454 
    if result.success is not None:
3455 
      return result.success
3456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3457 
 
7897 amar.kumar 3458 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3459 
    """
3460 
    Returns a list of count of requests for product notification against each item
3461 
 
3462 
    Parameters:
3463 
     - startDateTime
7897 amar.kumar 3464 
     - categoryId
5944 mandeep.dh 3465 
    """
7897 amar.kumar 3466 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3467 
    return self.recv_getProductNotificationRequestCount()
3468 
 
7897 amar.kumar 3469 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3470 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3471 
    args = getProductNotificationRequestCount_args()
3472 
    args.startDateTime = startDateTime
7897 amar.kumar 3473 
    args.categoryId = categoryId
5944 mandeep.dh 3474 
    args.write(self._oprot)
3475 
    self._oprot.writeMessageEnd()
3476 
    self._oprot.trans.flush()
3477 
 
3478 
  def recv_getProductNotificationRequestCount(self, ):
3479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3480 
    if mtype == TMessageType.EXCEPTION:
3481 
      x = TApplicationException()
3482 
      x.read(self._iprot)
3483 
      self._iprot.readMessageEnd()
3484 
      raise x
3485 
    result = getProductNotificationRequestCount_result()
3486 
    result.read(self._iprot)
3487 
    self._iprot.readMessageEnd()
3488 
    if result.success is not None:
3489 
      return result.success
3490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3491 
 
3492 
  def addAuthorizationLog(self, itemId, username, reason):
3493 
    """
3494 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3495 
 
3496 
    Parameters:
3497 
     - itemId
3498 
     - username
3499 
     - reason
3500 
    """
3501 
    self.send_addAuthorizationLog(itemId, username, reason)
3502 
    return self.recv_addAuthorizationLog()
3503 
 
3504 
  def send_addAuthorizationLog(self, itemId, username, reason):
3505 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3506 
    args = addAuthorizationLog_args()
3507 
    args.itemId = itemId
3508 
    args.username = username
3509 
    args.reason = reason
3510 
    args.write(self._oprot)
3511 
    self._oprot.writeMessageEnd()
3512 
    self._oprot.trans.flush()
3513 
 
3514 
  def recv_addAuthorizationLog(self, ):
3515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3516 
    if mtype == TMessageType.EXCEPTION:
3517 
      x = TApplicationException()
3518 
      x.read(self._iprot)
3519 
      self._iprot.readMessageEnd()
3520 
      raise x
3521 
    result = addAuthorizationLog_result()
3522 
    result.read(self._iprot)
3523 
    self._iprot.readMessageEnd()
3524 
    if result.success is not None:
3525 
      return result.success
3526 
    if result.cex is not None:
3527 
      raise result.cex
3528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3529 
 
3530 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3531 
    """
3532 
    Parameters:
3533 
     - catalog_item_id
3534 
     - voucherType
3535 
     - voucherAmount
3536 
    """
3537 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3538 
    return self.recv_addupdateVoucherForItem()
3539 
 
3540 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3541 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3542 
    args = addupdateVoucherForItem_args()
3543 
    args.catalog_item_id = catalog_item_id
3544 
    args.voucherType = voucherType
3545 
    args.voucherAmount = voucherAmount
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_addupdateVoucherForItem(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = addupdateVoucherForItem_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    if result.success is not None:
3561 
      return result.success
3562 
    if result.cex is not None:
3563 
      raise result.cex
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3565 
 
3566 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3567 
    """
3568 
    Parameters:
3569 
     - catalog_item_id
3570 
     - voucherType
3571 
    """
3572 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3573 
    return self.recv_deleteVoucherForItem()
3574 
 
3575 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3576 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3577 
    args = deleteVoucherForItem_args()
3578 
    args.catalog_item_id = catalog_item_id
3579 
    args.voucherType = voucherType
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_deleteVoucherForItem(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = deleteVoucherForItem_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.success is not None:
3595 
      return result.success
3596 
    if result.cex is not None:
3597 
      raise result.cex
3598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3599 
 
3600 
  def getVoucherAmount(self, itemId, voucherType):
3601 
    """
3602 
    Parameters:
3603 
     - itemId
3604 
     - voucherType
3605 
    """
3606 
    self.send_getVoucherAmount(itemId, voucherType)
3607 
    return self.recv_getVoucherAmount()
3608 
 
3609 
  def send_getVoucherAmount(self, itemId, voucherType):
3610 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3611 
    args = getVoucherAmount_args()
3612 
    args.itemId = itemId
3613 
    args.voucherType = voucherType
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_getVoucherAmount(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = getVoucherAmount_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
3628 
    if result.success is not None:
3629 
      return result.success
3630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3631 
 
3632 
  def getAllItemVouchers(self, itemId):
3633 
    """
3634 
    Parameters:
3635 
     - itemId
3636 
    """
3637 
    self.send_getAllItemVouchers(itemId)
3638 
    return self.recv_getAllItemVouchers()
3639 
 
3640 
  def send_getAllItemVouchers(self, itemId):
3641 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3642 
    args = getAllItemVouchers_args()
3643 
    args.itemId = itemId
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_getAllItemVouchers(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = getAllItemVouchers_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3658 
    if result.success is not None:
3659 
      return result.success
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3661 
 
3662 
  def isValidCatalogItemId(self, catalog_item_id):
3663 
    """
3664 
    Parameters:
3665 
     - catalog_item_id
3666 
    """
3667 
    self.send_isValidCatalogItemId(catalog_item_id)
3668 
    return self.recv_isValidCatalogItemId()
3669 
 
3670 
  def send_isValidCatalogItemId(self, catalog_item_id):
3671 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3672 
    args = isValidCatalogItemId_args()
3673 
    args.catalog_item_id = catalog_item_id
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_isValidCatalogItemId(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = isValidCatalogItemId_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3691 
 
7330 amit.gupta 3692 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3693 
    """
3694 
    Parameters:
3695 
     - itemId
7330 amit.gupta 3696 
     - stateId
6039 amit.gupta 3697 
     - price
3698 
    """
7330 amit.gupta 3699 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3700 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3701 
 
7330 amit.gupta 3702 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3703 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3704 
    args = getVatPercentageForItem_args()
3705 
    args.itemId = itemId
7330 amit.gupta 3706 
    args.stateId = stateId
6039 amit.gupta 3707 
    args.price = price
3708 
    args.write(self._oprot)
3709 
    self._oprot.writeMessageEnd()
3710 
    self._oprot.trans.flush()
3711 
 
3712 
  def recv_getVatPercentageForItem(self, ):
3713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3714 
    if mtype == TMessageType.EXCEPTION:
3715 
      x = TApplicationException()
3716 
      x.read(self._iprot)
3717 
      self._iprot.readMessageEnd()
3718 
      raise x
3719 
    result = getVatPercentageForItem_result()
3720 
    result.read(self._iprot)
3721 
    self._iprot.readMessageEnd()
3722 
    if result.success is not None:
3723 
      return result.success
7340 amit.gupta 3724 
    if result.cex is not None:
3725 
      raise result.cex
6039 amit.gupta 3726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3727 
 
3728 
  def getVatAmountForItem(self, itemId, price):
3729 
    """
3730 
    Parameters:
3731 
     - itemId
3732 
     - price
3733 
    """
3734 
    self.send_getVatAmountForItem(itemId, price)
3735 
    return self.recv_getVatAmountForItem()
3736 
 
3737 
  def send_getVatAmountForItem(self, itemId, price):
3738 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3739 
    args = getVatAmountForItem_args()
3740 
    args.itemId = itemId
3741 
    args.price = price
3742 
    args.write(self._oprot)
3743 
    self._oprot.writeMessageEnd()
3744 
    self._oprot.trans.flush()
3745 
 
3746 
  def recv_getVatAmountForItem(self, ):
3747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3748 
    if mtype == TMessageType.EXCEPTION:
3749 
      x = TApplicationException()
3750 
      x.read(self._iprot)
3751 
      self._iprot.readMessageEnd()
3752 
      raise x
3753 
    result = getVatAmountForItem_result()
3754 
    result.read(self._iprot)
3755 
    self._iprot.readMessageEnd()
3756 
    if result.success is not None:
3757 
      return result.success
3758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3759 
 
6531 vikram.rag 3760 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3761 
    """
3762 
    Parameters:
3763 
     - offset
3764 
     - limit
3765 
    """
3766 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3767 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3768 
 
6531 vikram.rag 3769 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3770 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3771 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3772 
    args.offset = offset
3773 
    args.limit = limit
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3780 
    if mtype == TMessageType.EXCEPTION:
3781 
      x = TApplicationException()
3782 
      x.read(self._iprot)
3783 
      self._iprot.readMessageEnd()
3784 
      raise x
3785 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3788 
    if result.success is not None:
3789 
      return result.success
3790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3791 
 
6821 amar.kumar 3792 
  def getAllAliveItems(self, ):
3793 
    self.send_getAllAliveItems()
3794 
    return self.recv_getAllAliveItems()
3795 
 
3796 
  def send_getAllAliveItems(self, ):
3797 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3798 
    args = getAllAliveItems_args()
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_getAllAliveItems(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = getAllAliveItems_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.success is not None:
3814 
      return result.success
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3816 
 
6921 anupam.sin 3817 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3818 
    """
3819 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3820 
 
6805 anupam.sin 3821 
    Parameters:
3822 
     - itemId
6921 anupam.sin 3823 
     - price
6805 anupam.sin 3824 
     - insurerId
3825 
     - quantity
3826 
    """
6921 anupam.sin 3827 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3828 
    return self.recv_getInsuranceAmount()
3829 
 
6921 anupam.sin 3830 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3831 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3832 
    args = getInsuranceAmount_args()
3833 
    args.itemId = itemId
6921 anupam.sin 3834 
    args.price = price
6805 anupam.sin 3835 
    args.insurerId = insurerId
3836 
    args.quantity = quantity
3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_getInsuranceAmount(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = getInsuranceAmount_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.success is not None:
3852 
      return result.success
3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3854 
 
3855 
  def getInsurer(self, insurerId):
3856 
    """
3857 
    Parameters:
3858 
     - insurerId
3859 
    """
3860 
    self.send_getInsurer(insurerId)
3861 
    return self.recv_getInsurer()
3862 
 
3863 
  def send_getInsurer(self, insurerId):
3864 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3865 
    args = getInsurer_args()
3866 
    args.insurerId = insurerId
3867 
    args.write(self._oprot)
3868 
    self._oprot.writeMessageEnd()
3869 
    self._oprot.trans.flush()
3870 
 
3871 
  def recv_getInsurer(self, ):
3872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3873 
    if mtype == TMessageType.EXCEPTION:
3874 
      x = TApplicationException()
3875 
      x.read(self._iprot)
3876 
      self._iprot.readMessageEnd()
3877 
      raise x
3878 
    result = getInsurer_result()
3879 
    result.read(self._iprot)
3880 
    self._iprot.readMessageEnd()
3881 
    if result.success is not None:
3882 
      return result.success
3883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3884 
 
6838 vikram.rag 3885 
  def getAllInsurers(self, ):
3886 
    self.send_getAllInsurers()
3887 
    return self.recv_getAllInsurers()
6805 anupam.sin 3888 
 
6838 vikram.rag 3889 
  def send_getAllInsurers(self, ):
3890 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3891 
    args = getAllInsurers_args()
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_getAllInsurers(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = getAllInsurers_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3906 
    if result.success is not None:
3907 
      return result.success
3908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3909 
 
6962 rajveer 3910 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3911 
    """
3912 
    Parameters:
3913 
     - insurerId
3914 
     - amount
3915 
    """
3916 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3917 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3918 
 
6962 rajveer 3919 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3920 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3921 
    args = updateInsuranceDeclaredAmount_args()
3922 
    args.insurerId = insurerId
3923 
    args.amount = amount
3924 
    args.write(self._oprot)
3925 
    self._oprot.writeMessageEnd()
3926 
    self._oprot.trans.flush()
3927 
 
3928 
  def recv_updateInsuranceDeclaredAmount(self, ):
3929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3930 
    if mtype == TMessageType.EXCEPTION:
3931 
      x = TApplicationException()
3932 
      x.read(self._iprot)
3933 
      self._iprot.readMessageEnd()
3934 
      raise x
3935 
    result = updateInsuranceDeclaredAmount_result()
3936 
    result.read(self._iprot)
3937 
    self._iprot.readMessageEnd()
3938 
    return
3939 
 
7190 amar.kumar 3940 
  def getFreebieForItem(self, itemId):
3941 
    """
3942 
    Parameters:
3943 
     - itemId
3944 
    """
3945 
    self.send_getFreebieForItem(itemId)
3946 
    return self.recv_getFreebieForItem()
6962 rajveer 3947 
 
7190 amar.kumar 3948 
  def send_getFreebieForItem(self, itemId):
3949 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3950 
    args = getFreebieForItem_args()
3951 
    args.itemId = itemId
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_getFreebieForItem(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = getFreebieForItem_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3966 
    if result.success is not None:
3967 
      return result.success
3968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3969 
 
3970 
  def addOrUpdateFreebieForItem(self, freebieItem):
3971 
    """
3972 
    Parameters:
3973 
     - freebieItem
3974 
    """
3975 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3976 
    self.recv_addOrUpdateFreebieForItem()
3977 
 
3978 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3979 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3980 
    args = addOrUpdateFreebieForItem_args()
3981 
    args.freebieItem = freebieItem
3982 
    args.write(self._oprot)
3983 
    self._oprot.writeMessageEnd()
3984 
    self._oprot.trans.flush()
3985 
 
3986 
  def recv_addOrUpdateFreebieForItem(self, ):
3987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3988 
    if mtype == TMessageType.EXCEPTION:
3989 
      x = TApplicationException()
3990 
      x.read(self._iprot)
3991 
      self._iprot.readMessageEnd()
3992 
      raise x
3993 
    result = addOrUpdateFreebieForItem_result()
3994 
    result.read(self._iprot)
3995 
    self._iprot.readMessageEnd()
3996 
    return
3997 
 
7272 amit.gupta 3998 
  def addOrUpdateBrandInfo(self, brandInfo):
3999 
    """
4000 
    Parameters:
4001 
     - brandInfo
4002 
    """
4003 
    self.send_addOrUpdateBrandInfo(brandInfo)
4004 
    self.recv_addOrUpdateBrandInfo()
4005 
 
4006 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4007 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4008 
    args = addOrUpdateBrandInfo_args()
4009 
    args.brandInfo = brandInfo
4010 
    args.write(self._oprot)
4011 
    self._oprot.writeMessageEnd()
4012 
    self._oprot.trans.flush()
4013 
 
4014 
  def recv_addOrUpdateBrandInfo(self, ):
4015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4016 
    if mtype == TMessageType.EXCEPTION:
4017 
      x = TApplicationException()
4018 
      x.read(self._iprot)
4019 
      self._iprot.readMessageEnd()
4020 
      raise x
4021 
    result = addOrUpdateBrandInfo_result()
4022 
    result.read(self._iprot)
4023 
    self._iprot.readMessageEnd()
4024 
    return
4025 
 
4026 
  def getBrandInfo(self, ):
4027 
    self.send_getBrandInfo()
4028 
    return self.recv_getBrandInfo()
4029 
 
4030 
  def send_getBrandInfo(self, ):
4031 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4032 
    args = getBrandInfo_args()
4033 
    args.write(self._oprot)
4034 
    self._oprot.writeMessageEnd()
4035 
    self._oprot.trans.flush()
4036 
 
4037 
  def recv_getBrandInfo(self, ):
4038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4039 
    if mtype == TMessageType.EXCEPTION:
4040 
      x = TApplicationException()
4041 
      x.read(self._iprot)
4042 
      self._iprot.readMessageEnd()
4043 
      raise x
4044 
    result = getBrandInfo_result()
4045 
    result.read(self._iprot)
4046 
    self._iprot.readMessageEnd()
4047 
    if result.success is not None:
4048 
      return result.success
4049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4050 
 
7256 rajveer 4051 
  def getStorePricing(self, itemId):
4052 
    """
4053 
    Parameters:
4054 
     - itemId
4055 
    """
4056 
    self.send_getStorePricing(itemId)
4057 
    return self.recv_getStorePricing()
7190 amar.kumar 4058 
 
7256 rajveer 4059 
  def send_getStorePricing(self, itemId):
4060 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4061 
    args = getStorePricing_args()
4062 
    args.itemId = itemId
4063 
    args.write(self._oprot)
4064 
    self._oprot.writeMessageEnd()
4065 
    self._oprot.trans.flush()
4066 
 
4067 
  def recv_getStorePricing(self, ):
4068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4069 
    if mtype == TMessageType.EXCEPTION:
4070 
      x = TApplicationException()
4071 
      x.read(self._iprot)
4072 
      self._iprot.readMessageEnd()
4073 
      raise x
4074 
    result = getStorePricing_result()
4075 
    result.read(self._iprot)
4076 
    self._iprot.readMessageEnd()
4077 
    if result.success is not None:
4078 
      return result.success
4079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4080 
 
7306 rajveer 4081 
  def getStorePricings(self, itemIds):
4082 
    """
4083 
    Parameters:
4084 
     - itemIds
4085 
    """
4086 
    self.send_getStorePricings(itemIds)
4087 
    return self.recv_getStorePricings()
4088 
 
4089 
  def send_getStorePricings(self, itemIds):
4090 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4091 
    args = getStorePricings_args()
4092 
    args.itemIds = itemIds
4093 
    args.write(self._oprot)
4094 
    self._oprot.writeMessageEnd()
4095 
    self._oprot.trans.flush()
4096 
 
4097 
  def recv_getStorePricings(self, ):
4098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4099 
    if mtype == TMessageType.EXCEPTION:
4100 
      x = TApplicationException()
4101 
      x.read(self._iprot)
4102 
      self._iprot.readMessageEnd()
4103 
      raise x
4104 
    result = getStorePricings_result()
4105 
    result.read(self._iprot)
4106 
    self._iprot.readMessageEnd()
4107 
    if result.success is not None:
4108 
      return result.success
4109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4110 
 
7382 rajveer 4111 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4112 
    """
4113 
    Parameters:
4114 
     - sp
7382 rajveer 4115 
     - allColors
7265 rajveer 4116 
    """
7382 rajveer 4117 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4118 
    self.recv_updateStorePricing()
7256 rajveer 4119 
 
7382 rajveer 4120 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4121 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4122 
    args = updateStorePricing_args()
4123 
    args.sp = sp
7382 rajveer 4124 
    args.allColors = allColors
7265 rajveer 4125 
    args.write(self._oprot)
4126 
    self._oprot.writeMessageEnd()
4127 
    self._oprot.trans.flush()
4128 
 
4129 
  def recv_updateStorePricing(self, ):
4130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4131 
    if mtype == TMessageType.EXCEPTION:
4132 
      x = TApplicationException()
4133 
      x.read(self._iprot)
4134 
      self._iprot.readMessageEnd()
4135 
      raise x
4136 
    result = updateStorePricing_result()
4137 
    result.read(self._iprot)
4138 
    self._iprot.readMessageEnd()
4139 
    return
4140 
 
7281 kshitij.so 4141 
  def getAllAmazonListedItems(self, ):
4142 
    self.send_getAllAmazonListedItems()
4143 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4144 
 
7281 kshitij.so 4145 
  def send_getAllAmazonListedItems(self, ):
4146 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4147 
    args = getAllAmazonListedItems_args()
4148 
    args.write(self._oprot)
4149 
    self._oprot.writeMessageEnd()
4150 
    self._oprot.trans.flush()
4151 
 
4152 
  def recv_getAllAmazonListedItems(self, ):
4153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4154 
    if mtype == TMessageType.EXCEPTION:
4155 
      x = TApplicationException()
4156 
      x.read(self._iprot)
4157 
      self._iprot.readMessageEnd()
4158 
      raise x
4159 
    result = getAllAmazonListedItems_result()
4160 
    result.read(self._iprot)
4161 
    self._iprot.readMessageEnd()
4162 
    if result.success is not None:
4163 
      return result.success
4164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4165 
 
8619 kshitij.so 4166 
  def searchAmazonItems(self, searchTerm, offset, limit):
4167 
    """
4168 
    Parameters:
4169 
     - searchTerm
4170 
     - offset
4171 
     - limit
4172 
    """
4173 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4174 
    return self.recv_searchAmazonItems()
4175 
 
4176 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4177 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4178 
    args = searchAmazonItems_args()
4179 
    args.searchTerm = searchTerm
4180 
    args.offset = offset
4181 
    args.limit = limit
4182 
    args.write(self._oprot)
4183 
    self._oprot.writeMessageEnd()
4184 
    self._oprot.trans.flush()
4185 
 
4186 
  def recv_searchAmazonItems(self, ):
4187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4188 
    if mtype == TMessageType.EXCEPTION:
4189 
      x = TApplicationException()
4190 
      x.read(self._iprot)
4191 
      self._iprot.readMessageEnd()
4192 
      raise x
4193 
    result = searchAmazonItems_result()
4194 
    result.read(self._iprot)
4195 
    self._iprot.readMessageEnd()
4196 
    if result.success is not None:
4197 
      return result.success
4198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4199 
 
4200 
  def getAmazonSearchResultCount(self, searchTerm):
4201 
    """
4202 
    Parameters:
4203 
     - searchTerm
4204 
    """
4205 
    self.send_getAmazonSearchResultCount(searchTerm)
4206 
    return self.recv_getAmazonSearchResultCount()
4207 
 
4208 
  def send_getAmazonSearchResultCount(self, searchTerm):
4209 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4210 
    args = getAmazonSearchResultCount_args()
4211 
    args.searchTerm = searchTerm
4212 
    args.write(self._oprot)
4213 
    self._oprot.writeMessageEnd()
4214 
    self._oprot.trans.flush()
4215 
 
4216 
  def recv_getAmazonSearchResultCount(self, ):
4217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4218 
    if mtype == TMessageType.EXCEPTION:
4219 
      x = TApplicationException()
4220 
      x.read(self._iprot)
4221 
      self._iprot.readMessageEnd()
4222 
      raise x
4223 
    result = getAmazonSearchResultCount_result()
4224 
    result.read(self._iprot)
4225 
    self._iprot.readMessageEnd()
4226 
    if result.success is not None:
4227 
      return result.success
4228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4229 
 
4230 
  def getCountForAmazonlistedItems(self, ):
4231 
    self.send_getCountForAmazonlistedItems()
4232 
    return self.recv_getCountForAmazonlistedItems()
4233 
 
4234 
  def send_getCountForAmazonlistedItems(self, ):
4235 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4236 
    args = getCountForAmazonlistedItems_args()
4237 
    args.write(self._oprot)
4238 
    self._oprot.writeMessageEnd()
4239 
    self._oprot.trans.flush()
4240 
 
4241 
  def recv_getCountForAmazonlistedItems(self, ):
4242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4243 
    if mtype == TMessageType.EXCEPTION:
4244 
      x = TApplicationException()
4245 
      x.read(self._iprot)
4246 
      self._iprot.readMessageEnd()
4247 
      raise x
4248 
    result = getCountForAmazonlistedItems_result()
4249 
    result.read(self._iprot)
4250 
    self._iprot.readMessageEnd()
4251 
    if result.success is not None:
4252 
      return result.success
4253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4254 
 
7281 kshitij.so 4255 
  def getAmazonItemDetails(self, itemId):
4256 
    """
4257 
    Parameters:
4258 
     - itemId
4259 
    """
4260 
    self.send_getAmazonItemDetails(itemId)
4261 
    return self.recv_getAmazonItemDetails()
4262 
 
4263 
  def send_getAmazonItemDetails(self, itemId):
4264 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4265 
    args = getAmazonItemDetails_args()
4266 
    args.itemId = itemId
4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_getAmazonItemDetails(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = getAmazonItemDetails_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    if result.success is not None:
4282 
      return result.success
4283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4284 
 
8168 kshitij.so 4285 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4286 
    """
4287 
    Parameters:
8168 kshitij.so 4288 
     - amazonlisted
7281 kshitij.so 4289 
    """
8168 kshitij.so 4290 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4291 
    self.recv_updateAmazonItemDetails()
4292 
 
8168 kshitij.so 4293 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4294 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4295 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4296 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4297 
    args.write(self._oprot)
4298 
    self._oprot.writeMessageEnd()
4299 
    self._oprot.trans.flush()
4300 
 
4301 
  def recv_updateAmazonItemDetails(self, ):
4302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4303 
    if mtype == TMessageType.EXCEPTION:
4304 
      x = TApplicationException()
4305 
      x.read(self._iprot)
4306 
      self._iprot.readMessageEnd()
4307 
      raise x
4308 
    result = updateAmazonItemDetails_result()
4309 
    result.read(self._iprot)
4310 
    self._iprot.readMessageEnd()
4311 
    return
4312 
 
4313 
  def addAmazonItem(self, amazonlisted):
4314 
    """
4315 
    Parameters:
4316 
     - amazonlisted
4317 
    """
4318 
    self.send_addAmazonItem(amazonlisted)
4319 
    self.recv_addAmazonItem()
4320 
 
4321 
  def send_addAmazonItem(self, amazonlisted):
4322 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4323 
    args = addAmazonItem_args()
4324 
    args.amazonlisted = amazonlisted
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_addAmazonItem(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = addAmazonItem_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    return
4340 
 
7291 vikram.rag 4341 
  def getAsinItems(self, ):
4342 
    self.send_getAsinItems()
4343 
    return self.recv_getAsinItems()
7281 kshitij.so 4344 
 
7291 vikram.rag 4345 
  def send_getAsinItems(self, ):
4346 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4347 
    args = getAsinItems_args()
4348 
    args.write(self._oprot)
4349 
    self._oprot.writeMessageEnd()
4350 
    self._oprot.trans.flush()
4351 
 
4352 
  def recv_getAsinItems(self, ):
4353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4354 
    if mtype == TMessageType.EXCEPTION:
4355 
      x = TApplicationException()
4356 
      x.read(self._iprot)
4357 
      self._iprot.readMessageEnd()
4358 
      raise x
4359 
    result = getAsinItems_result()
4360 
    result.read(self._iprot)
4361 
    self._iprot.readMessageEnd()
4362 
    if result.success is not None:
4363 
      return result.success
4364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4365 
 
4366 
  def getAllFbaListedItems(self, ):
4367 
    self.send_getAllFbaListedItems()
4368 
    return self.recv_getAllFbaListedItems()
4369 
 
4370 
  def send_getAllFbaListedItems(self, ):
4371 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4372 
    args = getAllFbaListedItems_args()
4373 
    args.write(self._oprot)
4374 
    self._oprot.writeMessageEnd()
4375 
    self._oprot.trans.flush()
4376 
 
4377 
  def recv_getAllFbaListedItems(self, ):
4378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4379 
    if mtype == TMessageType.EXCEPTION:
4380 
      x = TApplicationException()
4381 
      x.read(self._iprot)
4382 
      self._iprot.readMessageEnd()
4383 
      raise x
4384 
    result = getAllFbaListedItems_result()
4385 
    result.read(self._iprot)
4386 
    self._iprot.readMessageEnd()
4387 
    if result.success is not None:
4388 
      return result.success
4389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4390 
 
4391 
  def getAllNonFbaListedItems(self, ):
4392 
    self.send_getAllNonFbaListedItems()
4393 
    return self.recv_getAllNonFbaListedItems()
4394 
 
4395 
  def send_getAllNonFbaListedItems(self, ):
4396 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4397 
    args = getAllNonFbaListedItems_args()
4398 
    args.write(self._oprot)
4399 
    self._oprot.writeMessageEnd()
4400 
    self._oprot.trans.flush()
4401 
 
4402 
  def recv_getAllNonFbaListedItems(self, ):
4403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4404 
    if mtype == TMessageType.EXCEPTION:
4405 
      x = TApplicationException()
4406 
      x.read(self._iprot)
4407 
      self._iprot.readMessageEnd()
4408 
      raise x
4409 
    result = getAllNonFbaListedItems_result()
4410 
    result.read(self._iprot)
4411 
    self._iprot.readMessageEnd()
4412 
    if result.success is not None:
4413 
      return result.success
4414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4415 
 
7460 kshitij.so 4416 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4417 
    """
4418 
    Parameters:
4419 
     - itemId
4420 
     - holdInventory
4421 
     - defaultInventory
4422 
    """
4423 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4424 
    return self.recv_updateItemInventory()
7291 vikram.rag 4425 
 
7460 kshitij.so 4426 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4427 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4428 
    args = updateItemInventory_args()
4429 
    args.itemId = itemId
4430 
    args.holdInventory = holdInventory
4431 
    args.defaultInventory = defaultInventory
4432 
    args.write(self._oprot)
4433 
    self._oprot.writeMessageEnd()
4434 
    self._oprot.trans.flush()
4435 
 
4436 
  def recv_updateItemInventory(self, ):
4437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4438 
    if mtype == TMessageType.EXCEPTION:
4439 
      x = TApplicationException()
4440 
      x.read(self._iprot)
4441 
      self._iprot.readMessageEnd()
4442 
      raise x
4443 
    result = updateItemInventory_result()
4444 
    result.read(self._iprot)
4445 
    self._iprot.readMessageEnd()
4446 
    if result.success is not None:
4447 
      return result.success
4448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4449 
 
7770 kshitij.so 4450 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4451 
    """
4452 
    Parameters:
4453 
     - type
4454 
     - sku
4455 
     - timestamp
4456 
    """
4457 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4458 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4459 
 
7770 kshitij.so 4460 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4461 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4462 
    args = updateTimestampForAmazonFeeds_args()
4463 
    args.type = type
4464 
    args.sku = sku
4465 
    args.timestamp = timestamp
4466 
    args.write(self._oprot)
4467 
    self._oprot.writeMessageEnd()
4468 
    self._oprot.trans.flush()
4469 
 
4470 
  def recv_updateTimestampForAmazonFeeds(self, ):
4471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4472 
    if mtype == TMessageType.EXCEPTION:
4473 
      x = TApplicationException()
4474 
      x.read(self._iprot)
4475 
      self._iprot.readMessageEnd()
4476 
      raise x
4477 
    result = updateTimestampForAmazonFeeds_result()
4478 
    result.read(self._iprot)
4479 
    self._iprot.readMessageEnd()
4480 
    if result.success is not None:
4481 
      return result.success
4482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4483 
 
7897 amar.kumar 4484 
  def getAllParentCategories(self, ):
4485 
    self.send_getAllParentCategories()
4486 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4487 
 
7897 amar.kumar 4488 
  def send_getAllParentCategories(self, ):
4489 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4490 
    args = getAllParentCategories_args()
4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_getAllParentCategories(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = getAllParentCategories_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    if result.success is not None:
4506 
      return result.success
4507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4508 
 
7977 kshitij.so 4509 
  def addPageViewEvent(self, pageViewEvents):
4510 
    """
4511 
    Parameters:
4512 
     - pageViewEvents
4513 
    """
4514 
    self.send_addPageViewEvent(pageViewEvents)
4515 
    self.recv_addPageViewEvent()
7897 amar.kumar 4516 
 
7977 kshitij.so 4517 
  def send_addPageViewEvent(self, pageViewEvents):
4518 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4519 
    args = addPageViewEvent_args()
4520 
    args.pageViewEvents = pageViewEvents
4521 
    args.write(self._oprot)
4522 
    self._oprot.writeMessageEnd()
4523 
    self._oprot.trans.flush()
4524 
 
4525 
  def recv_addPageViewEvent(self, ):
4526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4527 
    if mtype == TMessageType.EXCEPTION:
4528 
      x = TApplicationException()
4529 
      x.read(self._iprot)
4530 
      self._iprot.readMessageEnd()
4531 
      raise x
4532 
    result = addPageViewEvent_result()
4533 
    result.read(self._iprot)
4534 
    self._iprot.readMessageEnd()
4535 
    return
4536 
 
4537 
  def addCartEvent(self, cartEvents):
4538 
    """
4539 
    Parameters:
4540 
     - cartEvents
4541 
    """
4542 
    self.send_addCartEvent(cartEvents)
4543 
    self.recv_addCartEvent()
4544 
 
4545 
  def send_addCartEvent(self, cartEvents):
4546 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4547 
    args = addCartEvent_args()
4548 
    args.cartEvents = cartEvents
4549 
    args.write(self._oprot)
4550 
    self._oprot.writeMessageEnd()
4551 
    self._oprot.trans.flush()
4552 
 
4553 
  def recv_addCartEvent(self, ):
4554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4555 
    if mtype == TMessageType.EXCEPTION:
4556 
      x = TApplicationException()
4557 
      x.read(self._iprot)
4558 
      self._iprot.readMessageEnd()
4559 
      raise x
4560 
    result = addCartEvent_result()
4561 
    result.read(self._iprot)
4562 
    self._iprot.readMessageEnd()
4563 
    return
4564 
 
8182 amar.kumar 4565 
  def addEbayItem(self, ebayItem):
4566 
    """
4567 
    Parameters:
4568 
     - ebayItem
4569 
    """
4570 
    self.send_addEbayItem(ebayItem)
4571 
    self.recv_addEbayItem()
4572 
 
4573 
  def send_addEbayItem(self, ebayItem):
4574 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4575 
    args = addEbayItem_args()
4576 
    args.ebayItem = ebayItem
4577 
    args.write(self._oprot)
4578 
    self._oprot.writeMessageEnd()
4579 
    self._oprot.trans.flush()
4580 
 
4581 
  def recv_addEbayItem(self, ):
4582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4583 
    if mtype == TMessageType.EXCEPTION:
4584 
      x = TApplicationException()
4585 
      x.read(self._iprot)
4586 
      self._iprot.readMessageEnd()
4587 
      raise x
4588 
    result = addEbayItem_result()
4589 
    result.read(self._iprot)
4590 
    self._iprot.readMessageEnd()
4591 
    return
4592 
 
4593 
  def getEbayItem(self, listingId):
4594 
    """
4595 
    Parameters:
4596 
     - listingId
4597 
    """
4598 
    self.send_getEbayItem(listingId)
4599 
    return self.recv_getEbayItem()
4600 
 
4601 
  def send_getEbayItem(self, listingId):
4602 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4603 
    args = getEbayItem_args()
4604 
    args.listingId = listingId
4605 
    args.write(self._oprot)
4606 
    self._oprot.writeMessageEnd()
4607 
    self._oprot.trans.flush()
4608 
 
4609 
  def recv_getEbayItem(self, ):
4610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4611 
    if mtype == TMessageType.EXCEPTION:
4612 
      x = TApplicationException()
4613 
      x.read(self._iprot)
4614 
      self._iprot.readMessageEnd()
4615 
      raise x
4616 
    result = getEbayItem_result()
4617 
    result.read(self._iprot)
4618 
    self._iprot.readMessageEnd()
4619 
    if result.success is not None:
4620 
      return result.success
4621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4622 
 
4623 
  def updateEbayItem(self, ebayItem):
4624 
    """
4625 
    Parameters:
4626 
     - ebayItem
4627 
    """
4628 
    self.send_updateEbayItem(ebayItem)
4629 
    self.recv_updateEbayItem()
4630 
 
4631 
  def send_updateEbayItem(self, ebayItem):
4632 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4633 
    args = updateEbayItem_args()
4634 
    args.ebayItem = ebayItem
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_updateEbayItem(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = updateEbayItem_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    return
4650 
 
8139 kshitij.so 4651 
  def getAmazonListedItems(self, offset, limit):
4652 
    """
4653 
    Parameters:
4654 
     - offset
4655 
     - limit
4656 
    """
4657 
    self.send_getAmazonListedItems(offset, limit)
4658 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4659 
 
8139 kshitij.so 4660 
  def send_getAmazonListedItems(self, offset, limit):
4661 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4662 
    args = getAmazonListedItems_args()
4663 
    args.offset = offset
4664 
    args.limit = limit
4665 
    args.write(self._oprot)
4666 
    self._oprot.writeMessageEnd()
4667 
    self._oprot.trans.flush()
4668 
 
4669 
  def recv_getAmazonListedItems(self, ):
4670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4671 
    if mtype == TMessageType.EXCEPTION:
4672 
      x = TApplicationException()
4673 
      x.read(self._iprot)
4674 
      self._iprot.readMessageEnd()
4675 
      raise x
4676 
    result = getAmazonListedItems_result()
4677 
    result.read(self._iprot)
4678 
    self._iprot.readMessageEnd()
4679 
    if result.success is not None:
4680 
      return result.success
4681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4682 
 
8168 kshitij.so 4683 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4684 
    """
4685 
    Parameters:
4686 
     - amazonlisted
4687 
    """
4688 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4689 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4690 
 
8168 kshitij.so 4691 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4692 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4693 
    args = updateAmazonAttributesInBulk_args()
4694 
    args.amazonlisted = amazonlisted
4695 
    args.write(self._oprot)
4696 
    self._oprot.writeMessageEnd()
4697 
    self._oprot.trans.flush()
4698 
 
4699 
  def recv_updateAmazonAttributesInBulk(self, ):
4700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4701 
    if mtype == TMessageType.EXCEPTION:
4702 
      x = TApplicationException()
4703 
      x.read(self._iprot)
4704 
      self._iprot.readMessageEnd()
4705 
      raise x
4706 
    result = updateAmazonAttributesInBulk_result()
4707 
    result.read(self._iprot)
4708 
    self._iprot.readMessageEnd()
4709 
    if result.success is not None:
4710 
      return result.success
4711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4712 
 
8379 vikram.rag 4713 
  def getAllItemstoListOnFba(self, ):
4714 
    self.send_getAllItemstoListOnFba()
4715 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4716 
 
8379 vikram.rag 4717 
  def send_getAllItemstoListOnFba(self, ):
4718 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4719 
    args = getAllItemstoListOnFba_args()
4720 
    args.write(self._oprot)
4721 
    self._oprot.writeMessageEnd()
4722 
    self._oprot.trans.flush()
4723 
 
4724 
  def recv_getAllItemstoListOnFba(self, ):
4725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4726 
    if mtype == TMessageType.EXCEPTION:
4727 
      x = TApplicationException()
4728 
      x.read(self._iprot)
4729 
      self._iprot.readMessageEnd()
4730 
      raise x
4731 
    result = getAllItemstoListOnFba_result()
4732 
    result.read(self._iprot)
4733 
    self._iprot.readMessageEnd()
4734 
    if result.success is not None:
4735 
      return result.success
4736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4737 
 
4738 
  def getAllItemstoListOnNonFba(self, ):
4739 
    self.send_getAllItemstoListOnNonFba()
4740 
    return self.recv_getAllItemstoListOnNonFba()
4741 
 
4742 
  def send_getAllItemstoListOnNonFba(self, ):
4743 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4744 
    args = getAllItemstoListOnNonFba_args()
4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_getAllItemstoListOnNonFba(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = getAllItemstoListOnNonFba_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    if result.success is not None:
4760 
      return result.success
4761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4762 
 
8619 kshitij.so 4763 
  def updateAsin(self, item):
4764 
    """
4765 
    Parameters:
4766 
     - item
4767 
    """
4768 
    self.send_updateAsin(item)
4769 
    self.recv_updateAsin()
8616 vikram.rag 4770 
 
8619 kshitij.so 4771 
  def send_updateAsin(self, item):
4772 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4773 
    args = updateAsin_args()
4774 
    args.item = item
4775 
    args.write(self._oprot)
4776 
    self._oprot.writeMessageEnd()
4777 
    self._oprot.trans.flush()
4778 
 
4779 
  def recv_updateAsin(self, ):
4780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4781 
    if mtype == TMessageType.EXCEPTION:
4782 
      x = TApplicationException()
4783 
      x.read(self._iprot)
4784 
      self._iprot.readMessageEnd()
4785 
      raise x
4786 
    result = updateAsin_result()
4787 
    result.read(self._iprot)
4788 
    self._iprot.readMessageEnd()
4789 
    return
4790 
 
8739 vikram.rag 4791 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4792 
    """
4793 
    Parameters:
4794 
     - snapdealitem
4795 
    """
4796 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4797 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4798 
 
8739 vikram.rag 4799 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4800 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4801 
    args = addOrUpdateSnapdealItem_args()
4802 
    args.snapdealitem = snapdealitem
4803 
    args.write(self._oprot)
4804 
    self._oprot.writeMessageEnd()
4805 
    self._oprot.trans.flush()
4806 
 
4807 
  def recv_addOrUpdateSnapdealItem(self, ):
4808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4809 
    if mtype == TMessageType.EXCEPTION:
4810 
      x = TApplicationException()
4811 
      x.read(self._iprot)
4812 
      self._iprot.readMessageEnd()
4813 
      raise x
4814 
    result = addOrUpdateSnapdealItem_result()
4815 
    result.read(self._iprot)
4816 
    self._iprot.readMessageEnd()
4817 
    if result.success is not None:
4818 
      return result.success
4819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4820 
 
4821 
  def getSnapdealItem(self, item_id):
4822 
    """
4823 
    Parameters:
4824 
     - item_id
4825 
    """
4826 
    self.send_getSnapdealItem(item_id)
4827 
    return self.recv_getSnapdealItem()
4828 
 
4829 
  def send_getSnapdealItem(self, item_id):
4830 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4831 
    args = getSnapdealItem_args()
4832 
    args.item_id = item_id
4833 
    args.write(self._oprot)
4834 
    self._oprot.writeMessageEnd()
4835 
    self._oprot.trans.flush()
4836 
 
4837 
  def recv_getSnapdealItem(self, ):
4838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4839 
    if mtype == TMessageType.EXCEPTION:
4840 
      x = TApplicationException()
4841 
      x.read(self._iprot)
4842 
      self._iprot.readMessageEnd()
4843 
      raise x
4844 
    result = getSnapdealItem_result()
4845 
    result.read(self._iprot)
4846 
    self._iprot.readMessageEnd()
4847 
    if result.success is not None:
4848 
      return result.success
4849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4850 
 
9242 kshitij.so 4851 
  def getSnapdealItemDetails(self, item_id):
4852 
    """
4853 
    Parameters:
4854 
     - item_id
4855 
    """
4856 
    self.send_getSnapdealItemDetails(item_id)
4857 
    return self.recv_getSnapdealItemDetails()
4858 
 
4859 
  def send_getSnapdealItemDetails(self, item_id):
4860 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4861 
    args = getSnapdealItemDetails_args()
4862 
    args.item_id = item_id
4863 
    args.write(self._oprot)
4864 
    self._oprot.writeMessageEnd()
4865 
    self._oprot.trans.flush()
4866 
 
4867 
  def recv_getSnapdealItemDetails(self, ):
4868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4869 
    if mtype == TMessageType.EXCEPTION:
4870 
      x = TApplicationException()
4871 
      x.read(self._iprot)
4872 
      self._iprot.readMessageEnd()
4873 
      raise x
4874 
    result = getSnapdealItemDetails_result()
4875 
    result.read(self._iprot)
4876 
    self._iprot.readMessageEnd()
4877 
    if result.success is not None:
4878 
      return result.success
4879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4880 
 
8739 vikram.rag 4881 
  def getAllSnapdealItems(self, ):
4882 
    self.send_getAllSnapdealItems()
4883 
    return self.recv_getAllSnapdealItems()
4884 
 
4885 
  def send_getAllSnapdealItems(self, ):
4886 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4887 
    args = getAllSnapdealItems_args()
4888 
    args.write(self._oprot)
4889 
    self._oprot.writeMessageEnd()
4890 
    self._oprot.trans.flush()
4891 
 
4892 
  def recv_getAllSnapdealItems(self, ):
4893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4894 
    if mtype == TMessageType.EXCEPTION:
4895 
      x = TApplicationException()
4896 
      x.read(self._iprot)
4897 
      self._iprot.readMessageEnd()
4898 
      raise x
4899 
    result = getAllSnapdealItems_result()
4900 
    result.read(self._iprot)
4901 
    self._iprot.readMessageEnd()
4902 
    if result.success is not None:
4903 
      return result.success
4904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4905 
 
9242 kshitij.so 4906 
  def getSnapdealItems(self, offset, limit):
4907 
    """
4908 
    Parameters:
4909 
     - offset
4910 
     - limit
4911 
    """
4912 
    self.send_getSnapdealItems(offset, limit)
4913 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4914 
 
9242 kshitij.so 4915 
  def send_getSnapdealItems(self, offset, limit):
4916 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4917 
    args = getSnapdealItems_args()
4918 
    args.offset = offset
4919 
    args.limit = limit
4920 
    args.write(self._oprot)
4921 
    self._oprot.writeMessageEnd()
4922 
    self._oprot.trans.flush()
4923 
 
4924 
  def recv_getSnapdealItems(self, ):
4925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4926 
    if mtype == TMessageType.EXCEPTION:
4927 
      x = TApplicationException()
4928 
      x.read(self._iprot)
4929 
      self._iprot.readMessageEnd()
4930 
      raise x
4931 
    result = getSnapdealItems_result()
4932 
    result.read(self._iprot)
4933 
    self._iprot.readMessageEnd()
4934 
    if result.success is not None:
4935 
      return result.success
4936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4937 
 
4938 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4939 
    """
4940 
    Parameters:
4941 
     - searchTerm
4942 
     - offset
4943 
     - limit
4944 
    """
4945 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4946 
    return self.recv_searchSnapdealItems()
4947 
 
4948 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4949 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4950 
    args = searchSnapdealItems_args()
4951 
    args.searchTerm = searchTerm
4952 
    args.offset = offset
4953 
    args.limit = limit
4954 
    args.write(self._oprot)
4955 
    self._oprot.writeMessageEnd()
4956 
    self._oprot.trans.flush()
4957 
 
4958 
  def recv_searchSnapdealItems(self, ):
4959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4960 
    if mtype == TMessageType.EXCEPTION:
4961 
      x = TApplicationException()
4962 
      x.read(self._iprot)
4963 
      self._iprot.readMessageEnd()
4964 
      raise x
4965 
    result = searchSnapdealItems_result()
4966 
    result.read(self._iprot)
4967 
    self._iprot.readMessageEnd()
4968 
    if result.success is not None:
4969 
      return result.success
4970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4971 
 
4972 
  def getCountForSnapdealItems(self, ):
4973 
    self.send_getCountForSnapdealItems()
4974 
    return self.recv_getCountForSnapdealItems()
4975 
 
4976 
  def send_getCountForSnapdealItems(self, ):
4977 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4978 
    args = getCountForSnapdealItems_args()
4979 
    args.write(self._oprot)
4980 
    self._oprot.writeMessageEnd()
4981 
    self._oprot.trans.flush()
4982 
 
4983 
  def recv_getCountForSnapdealItems(self, ):
4984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4985 
    if mtype == TMessageType.EXCEPTION:
4986 
      x = TApplicationException()
4987 
      x.read(self._iprot)
4988 
      self._iprot.readMessageEnd()
4989 
      raise x
4990 
    result = getCountForSnapdealItems_result()
4991 
    result.read(self._iprot)
4992 
    self._iprot.readMessageEnd()
4993 
    if result.success is not None:
4994 
      return result.success
4995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
4996 
 
4997 
  def getSnapdealSearchResultCount(self, searchTerm):
4998 
    """
4999 
    Parameters:
5000 
     - searchTerm
5001 
    """
5002 
    self.send_getSnapdealSearchResultCount(searchTerm)
5003 
    return self.recv_getSnapdealSearchResultCount()
5004 
 
5005 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5006 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5007 
    args = getSnapdealSearchResultCount_args()
5008 
    args.searchTerm = searchTerm
5009 
    args.write(self._oprot)
5010 
    self._oprot.writeMessageEnd()
5011 
    self._oprot.trans.flush()
5012 
 
5013 
  def recv_getSnapdealSearchResultCount(self, ):
5014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5015 
    if mtype == TMessageType.EXCEPTION:
5016 
      x = TApplicationException()
5017 
      x.read(self._iprot)
5018 
      self._iprot.readMessageEnd()
5019 
      raise x
5020 
    result = getSnapdealSearchResultCount_result()
5021 
    result.read(self._iprot)
5022 
    self._iprot.readMessageEnd()
5023 
    if result.success is not None:
5024 
      return result.success
5025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5026 
 
9299 kshitij.so 5027 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5028 
    """
5029 
    Parameters:
5030 
     - itemId
5031 
     - insurerType
5032 
    """
5033 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5034 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5035 
 
9299 kshitij.so 5036 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5037 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5038 
    args = getPrefferedInsurerForItem_args()
5039 
    args.itemId = itemId
5040 
    args.insurerType = insurerType
5041 
    args.write(self._oprot)
5042 
    self._oprot.writeMessageEnd()
5043 
    self._oprot.trans.flush()
5044 
 
5045 
  def recv_getPrefferedInsurerForItem(self, ):
5046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5047 
    if mtype == TMessageType.EXCEPTION:
5048 
      x = TApplicationException()
5049 
      x.read(self._iprot)
5050 
      self._iprot.readMessageEnd()
5051 
      raise x
5052 
    result = getPrefferedInsurerForItem_result()
5053 
    result.read(self._iprot)
5054 
    self._iprot.readMessageEnd()
5055 
    if result.success is not None:
5056 
      return result.success
5057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5058 
 
9456 vikram.rag 5059 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5060 
    """
5061 
    Parameters:
5062 
     - skuAtSnapdeal
5063 
    """
5064 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5065 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5066 
 
9456 vikram.rag 5067 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5068 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5069 
    args = getSnapdealItembySkuAtSnapdeal_args()
5070 
    args.skuAtSnapdeal = skuAtSnapdeal
5071 
    args.write(self._oprot)
5072 
    self._oprot.writeMessageEnd()
5073 
    self._oprot.trans.flush()
5074 
 
5075 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5077 
    if mtype == TMessageType.EXCEPTION:
5078 
      x = TApplicationException()
5079 
      x.read(self._iprot)
5080 
      self._iprot.readMessageEnd()
5081 
      raise x
5082 
    result = getSnapdealItembySkuAtSnapdeal_result()
5083 
    result.read(self._iprot)
5084 
    self._iprot.readMessageEnd()
5085 
    if result.success is not None:
5086 
      return result.success
5087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5088 
 
9621 manish.sha 5089 
  def getProductFeedSubmit(self, catalogItemId):
5090 
    """
5091 
    Parameters:
5092 
     - catalogItemId
5093 
    """
5094 
    self.send_getProductFeedSubmit(catalogItemId)
5095 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5096 
 
9621 manish.sha 5097 
  def send_getProductFeedSubmit(self, catalogItemId):
5098 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5099 
    args = getProductFeedSubmit_args()
5100 
    args.catalogItemId = catalogItemId
5101 
    args.write(self._oprot)
5102 
    self._oprot.writeMessageEnd()
5103 
    self._oprot.trans.flush()
5104 
 
5105 
  def recv_getProductFeedSubmit(self, ):
5106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5107 
    if mtype == TMessageType.EXCEPTION:
5108 
      x = TApplicationException()
5109 
      x.read(self._iprot)
5110 
      self._iprot.readMessageEnd()
5111 
      raise x
5112 
    result = getProductFeedSubmit_result()
5113 
    result.read(self._iprot)
5114 
    self._iprot.readMessageEnd()
5115 
    if result.success is not None:
5116 
      return result.success
5117 
    if result.cex is not None:
5118 
      raise result.cex
5119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5120 
 
5121 
  def addProductFeedSubmit(self, productFeedSubmit):
5122 
    """
5123 
    Parameters:
5124 
     - productFeedSubmit
5125 
    """
5126 
    self.send_addProductFeedSubmit(productFeedSubmit)
5127 
    return self.recv_addProductFeedSubmit()
5128 
 
5129 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5130 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5131 
    args = addProductFeedSubmit_args()
5132 
    args.productFeedSubmit = productFeedSubmit
5133 
    args.write(self._oprot)
5134 
    self._oprot.writeMessageEnd()
5135 
    self._oprot.trans.flush()
5136 
 
5137 
  def recv_addProductFeedSubmit(self, ):
5138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5139 
    if mtype == TMessageType.EXCEPTION:
5140 
      x = TApplicationException()
5141 
      x.read(self._iprot)
5142 
      self._iprot.readMessageEnd()
5143 
      raise x
5144 
    result = addProductFeedSubmit_result()
5145 
    result.read(self._iprot)
5146 
    self._iprot.readMessageEnd()
5147 
    if result.success is not None:
5148 
      return result.success
5149 
    if result.cex is not None:
5150 
      raise result.cex
5151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5152 
 
5153 
  def updateProductFeedSubmit(self, productFeedSubmit):
5154 
    """
5155 
    Parameters:
5156 
     - productFeedSubmit
5157 
    """
5158 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5159 
    return self.recv_updateProductFeedSubmit()
5160 
 
5161 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5162 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5163 
    args = updateProductFeedSubmit_args()
5164 
    args.productFeedSubmit = productFeedSubmit
5165 
    args.write(self._oprot)
5166 
    self._oprot.writeMessageEnd()
5167 
    self._oprot.trans.flush()
5168 
 
5169 
  def recv_updateProductFeedSubmit(self, ):
5170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5171 
    if mtype == TMessageType.EXCEPTION:
5172 
      x = TApplicationException()
5173 
      x.read(self._iprot)
5174 
      self._iprot.readMessageEnd()
5175 
      raise x
5176 
    result = updateProductFeedSubmit_result()
5177 
    result.read(self._iprot)
5178 
    self._iprot.readMessageEnd()
5179 
    if result.success is not None:
5180 
      return result.success
5181 
    if result.cex is not None:
5182 
      raise result.cex
5183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5184 
 
5185 
  def deleteProductFeedSubmit(self, catalogItemId):
5186 
    """
5187 
    Parameters:
5188 
     - catalogItemId
5189 
    """
5190 
    self.send_deleteProductFeedSubmit(catalogItemId)
5191 
    return self.recv_deleteProductFeedSubmit()
5192 
 
5193 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5194 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5195 
    args = deleteProductFeedSubmit_args()
5196 
    args.catalogItemId = catalogItemId
5197 
    args.write(self._oprot)
5198 
    self._oprot.writeMessageEnd()
5199 
    self._oprot.trans.flush()
5200 
 
5201 
  def recv_deleteProductFeedSubmit(self, ):
5202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5203 
    if mtype == TMessageType.EXCEPTION:
5204 
      x = TApplicationException()
5205 
      x.read(self._iprot)
5206 
      self._iprot.readMessageEnd()
5207 
      raise x
5208 
    result = deleteProductFeedSubmit_result()
5209 
    result.read(self._iprot)
5210 
    self._iprot.readMessageEnd()
5211 
    if result.success is not None:
5212 
      return result.success
5213 
    if result.cex is not None:
5214 
      raise result.cex
5215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5216 
 
5217 
  def getAllProductFeedSubmit(self, ):
5218 
    self.send_getAllProductFeedSubmit()
5219 
    return self.recv_getAllProductFeedSubmit()
5220 
 
5221 
  def send_getAllProductFeedSubmit(self, ):
5222 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5223 
    args = getAllProductFeedSubmit_args()
5224 
    args.write(self._oprot)
5225 
    self._oprot.writeMessageEnd()
5226 
    self._oprot.trans.flush()
5227 
 
5228 
  def recv_getAllProductFeedSubmit(self, ):
5229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5230 
    if mtype == TMessageType.EXCEPTION:
5231 
      x = TApplicationException()
5232 
      x.read(self._iprot)
5233 
      self._iprot.readMessageEnd()
5234 
      raise x
5235 
    result = getAllProductFeedSubmit_result()
5236 
    result.read(self._iprot)
5237 
    self._iprot.readMessageEnd()
5238 
    if result.success is not None:
5239 
      return result.success
5240 
    if result.cex is not None:
5241 
      raise result.cex
5242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5243 
 
9724 kshitij.so 5244 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5245 
    """
5246 
    Parameters:
5247 
     - itemId
5248 
     - sourceId
5249 
    """
5250 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5251 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5252 
 
9724 kshitij.so 5253 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5254 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5255 
    args = getMarketplacedetailsForItem_args()
5256 
    args.itemId = itemId
5257 
    args.sourceId = sourceId
5258 
    args.write(self._oprot)
5259 
    self._oprot.writeMessageEnd()
5260 
    self._oprot.trans.flush()
5261 
 
5262 
  def recv_getMarketplacedetailsForItem(self, ):
5263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5264 
    if mtype == TMessageType.EXCEPTION:
5265 
      x = TApplicationException()
5266 
      x.read(self._iprot)
5267 
      self._iprot.readMessageEnd()
5268 
      raise x
5269 
    result = getMarketplacedetailsForItem_result()
5270 
    result.read(self._iprot)
5271 
    self._iprot.readMessageEnd()
5272 
    if result.success is not None:
5273 
      return result.success
5274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5275 
 
5276 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5277 
    """
5278 
    Parameters:
5279 
     - marketPlaceItem
5280 
    """
5281 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5282 
    return self.recv_updateMarketplaceAttributesForItem()
5283 
 
5284 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5285 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5286 
    args = updateMarketplaceAttributesForItem_args()
5287 
    args.marketPlaceItem = marketPlaceItem
5288 
    args.write(self._oprot)
5289 
    self._oprot.writeMessageEnd()
5290 
    self._oprot.trans.flush()
5291 
 
5292 
  def recv_updateMarketplaceAttributesForItem(self, ):
5293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5294 
    if mtype == TMessageType.EXCEPTION:
5295 
      x = TApplicationException()
5296 
      x.read(self._iprot)
5297 
      self._iprot.readMessageEnd()
5298 
      raise x
5299 
    result = updateMarketplaceAttributesForItem_result()
5300 
    result.read(self._iprot)
5301 
    self._iprot.readMessageEnd()
5302 
    if result.success is not None:
5303 
      return result.success
5304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5305 
 
9776 vikram.rag 5306 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5307 
    """
5308 
    Parameters:
5309 
     - source
5310 
    """
5311 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5312 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5313 
 
9776 vikram.rag 5314 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5315 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5316 
    args = getMarketPlaceItemsForPriceUpdate_args()
5317 
    args.source = source
5318 
    args.write(self._oprot)
5319 
    self._oprot.writeMessageEnd()
5320 
    self._oprot.trans.flush()
5321 
 
5322 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5324 
    if mtype == TMessageType.EXCEPTION:
5325 
      x = TApplicationException()
5326 
      x.read(self._iprot)
5327 
      self._iprot.readMessageEnd()
5328 
      raise x
5329 
    result = getMarketPlaceItemsForPriceUpdate_result()
5330 
    result.read(self._iprot)
5331 
    self._iprot.readMessageEnd()
5332 
    if result.success is not None:
5333 
      return result.success
5334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5335 
 
5336 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp):
5337 
    """
5338 
    Parameters:
5339 
     - skulist
5340 
     - timestamp
5341 
    """
5342 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp)
5343 
    self.recv_updateMarketPlacePriceUpdateStatus()
5344 
 
5345 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp):
5346 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5347 
    args = updateMarketPlacePriceUpdateStatus_args()
5348 
    args.skulist = skulist
5349 
    args.timestamp = timestamp
5350 
    args.write(self._oprot)
5351 
    self._oprot.writeMessageEnd()
5352 
    self._oprot.trans.flush()
5353 
 
5354 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5356 
    if mtype == TMessageType.EXCEPTION:
5357 
      x = TApplicationException()
5358 
      x.read(self._iprot)
5359 
      self._iprot.readMessageEnd()
5360 
      raise x
5361 
    result = updateMarketPlacePriceUpdateStatus_result()
5362 
    result.read(self._iprot)
5363 
    self._iprot.readMessageEnd()
5364 
    return
5365 
 
5366 
 
5944 mandeep.dh 5367 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5368 
  def __init__(self, handler):
5369 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5370 
    self._processMap["addItem"] = Processor.process_addItem
5371 
    self._processMap["updateItem"] = Processor.process_updateItem
5372 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5373 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5374 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5375 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5376 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5377 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5378 
    self._processMap["getItem"] = Processor.process_getItem
5379 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5380 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5381 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5382 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5383 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5384 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5385 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5386 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5387 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5388 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5389 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5390 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5391 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5392 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5393 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5394 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5395 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5396 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5397 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5398 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5399 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5400 
    self._processMap["addCategory"] = Processor.process_addCategory
5401 
    self._processMap["getCategory"] = Processor.process_getCategory
5402 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5403 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5404 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5405 
    self._processMap["addTag"] = Processor.process_addTag
5406 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5407 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5408 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5409 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5410 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5411 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5412 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5413 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5414 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5415 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5416 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5417 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5418 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5419 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5420 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5421 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5422 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5423 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5424 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5425 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5426 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5427 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5428 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5429 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5430 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5431 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5432 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5433 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5434 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5435 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5436 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5437 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5438 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5439 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5440 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5441 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5442 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5443 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5444 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5445 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5446 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5447 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5448 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5449 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5450 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5451 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5452 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5453 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5454 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5455 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5456 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5457 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5458 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5459 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5460 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5461 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5462 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5463 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5464 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5465 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5466 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5467 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5468 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5469 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5470 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5471 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5472 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5473 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5474 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5475 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5476 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5477 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5478 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5479 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5480 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5481 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5482 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5483 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5484 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5485 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5486 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5487 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5488 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5489 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5490 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5491 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5492 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5493 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5494 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5495 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5496 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5497 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5498 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5499 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5500 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5501 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5502 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5503 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5504 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5505 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5506 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5507 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5508 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9776 vikram.rag 5509 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5510 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
5944 mandeep.dh 5511 
 
5512 
  def process(self, iprot, oprot):
5513 
    (name, type, seqid) = iprot.readMessageBegin()
5514 
    if name not in self._processMap:
5515 
      iprot.skip(TType.STRUCT)
5516 
      iprot.readMessageEnd()
5517 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5518 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5519 
      x.write(oprot)
5520 
      oprot.writeMessageEnd()
5521 
      oprot.trans.flush()
5522 
      return
5523 
    else:
5524 
      self._processMap[name](self, seqid, iprot, oprot)
5525 
    return True
5526 
 
5527 
  def process_addItem(self, seqid, iprot, oprot):
5528 
    args = addItem_args()
5529 
    args.read(iprot)
5530 
    iprot.readMessageEnd()
5531 
    result = addItem_result()
5532 
    try:
5533 
      result.success = self._handler.addItem(args.item)
5534 
    except CatalogServiceException, cex:
5535 
      result.cex = cex
5536 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5537 
    result.write(oprot)
5538 
    oprot.writeMessageEnd()
5539 
    oprot.trans.flush()
5540 
 
5541 
  def process_updateItem(self, seqid, iprot, oprot):
5542 
    args = updateItem_args()
5543 
    args.read(iprot)
5544 
    iprot.readMessageEnd()
5545 
    result = updateItem_result()
5546 
    try:
5547 
      result.success = self._handler.updateItem(args.item)
5548 
    except CatalogServiceException, cex:
5549 
      result.cex = cex
5550 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5551 
    result.write(oprot)
5552 
    oprot.writeMessageEnd()
5553 
    oprot.trans.flush()
5554 
 
5555 
  def process_isActive(self, seqid, iprot, oprot):
5556 
    args = isActive_args()
5557 
    args.read(iprot)
5558 
    iprot.readMessageEnd()
5559 
    result = isActive_result()
5560 
    try:
5561 
      result.success = self._handler.isActive(args.itemId)
5562 
    except CatalogServiceException, isex:
5563 
      result.isex = isex
5564 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5565 
    result.write(oprot)
5566 
    oprot.writeMessageEnd()
5567 
    oprot.trans.flush()
5568 
 
7438 amit.gupta 5569 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5570 
    args = getItemsStatus_args()
5571 
    args.read(iprot)
5572 
    iprot.readMessageEnd()
5573 
    result = getItemsStatus_result()
5574 
    try:
5575 
      result.success = self._handler.getItemsStatus(args.itemIds)
5576 
    except CatalogServiceException, isex:
5577 
      result.isex = isex
5578 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5579 
    result.write(oprot)
5580 
    oprot.writeMessageEnd()
5581 
    oprot.trans.flush()
5582 
 
5944 mandeep.dh 5583 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5584 
    args = getItemStatusDescription_args()
5585 
    args.read(iprot)
5586 
    iprot.readMessageEnd()
5587 
    result = getItemStatusDescription_result()
5588 
    try:
5589 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5590 
    except CatalogServiceException, isex:
5591 
      result.isex = isex
5592 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5593 
    result.write(oprot)
5594 
    oprot.writeMessageEnd()
5595 
    oprot.trans.flush()
5596 
 
5597 
  def process_startItemOn(self, seqid, iprot, oprot):
5598 
    args = startItemOn_args()
5599 
    args.read(iprot)
5600 
    iprot.readMessageEnd()
5601 
    result = startItemOn_result()
5602 
    try:
5603 
      self._handler.startItemOn(args.item_id, args.timestamp)
5604 
    except CatalogServiceException, cex:
5605 
      result.cex = cex
5606 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5607 
    result.write(oprot)
5608 
    oprot.writeMessageEnd()
5609 
    oprot.trans.flush()
5610 
 
5611 
  def process_retireItemOn(self, seqid, iprot, oprot):
5612 
    args = retireItemOn_args()
5613 
    args.read(iprot)
5614 
    iprot.readMessageEnd()
5615 
    result = retireItemOn_result()
5616 
    try:
5617 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5618 
    except CatalogServiceException, cex:
5619 
      result.cex = cex
5620 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5621 
    result.write(oprot)
5622 
    oprot.writeMessageEnd()
5623 
    oprot.trans.flush()
5624 
 
5625 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5626 
    args = changeItemStatus_args()
5627 
    args.read(iprot)
5628 
    iprot.readMessageEnd()
5629 
    result = changeItemStatus_result()
5630 
    try:
5631 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5632 
    except CatalogServiceException, cex:
5633 
      result.cex = cex
5634 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5635 
    result.write(oprot)
5636 
    oprot.writeMessageEnd()
5637 
    oprot.trans.flush()
5638 
 
5639 
  def process_getItem(self, seqid, iprot, oprot):
5640 
    args = getItem_args()
5641 
    args.read(iprot)
5642 
    iprot.readMessageEnd()
5643 
    result = getItem_result()
5644 
    try:
5645 
      result.success = self._handler.getItem(args.item_id)
5646 
    except CatalogServiceException, cex:
5647 
      result.cex = cex
5648 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5649 
    result.write(oprot)
5650 
    oprot.writeMessageEnd()
5651 
    oprot.trans.flush()
5652 
 
5653 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5654 
    args = getItemsByCatalogId_args()
5655 
    args.read(iprot)
5656 
    iprot.readMessageEnd()
5657 
    result = getItemsByCatalogId_result()
5658 
    try:
5659 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5660 
    except CatalogServiceException, cex:
5661 
      result.cex = cex
5662 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5663 
    result.write(oprot)
5664 
    oprot.writeMessageEnd()
5665 
    oprot.trans.flush()
5666 
 
5667 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5668 
    args = getValidItemsByCatalogId_args()
5669 
    args.read(iprot)
5670 
    iprot.readMessageEnd()
5671 
    result = getValidItemsByCatalogId_result()
5672 
    try:
5673 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5674 
    except CatalogServiceException, cex:
5675 
      result.cex = cex
5676 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5677 
    result.write(oprot)
5678 
    oprot.writeMessageEnd()
5679 
    oprot.trans.flush()
5680 
 
5681 
  def process_getAllItems(self, seqid, iprot, oprot):
5682 
    args = getAllItems_args()
5683 
    args.read(iprot)
5684 
    iprot.readMessageEnd()
5685 
    result = getAllItems_result()
5686 
    try:
5687 
      result.success = self._handler.getAllItems(args.isActive)
5688 
    except CatalogServiceException, cex:
5689 
      result.cex = cex
5690 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5691 
    result.write(oprot)
5692 
    oprot.writeMessageEnd()
5693 
    oprot.trans.flush()
5694 
 
5695 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5696 
    args = getAllItemsByStatus_args()
5697 
    args.read(iprot)
5698 
    iprot.readMessageEnd()
5699 
    result = getAllItemsByStatus_result()
5700 
    try:
5701 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5702 
    except CatalogServiceException, cex:
5703 
      result.cex = cex
5704 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5705 
    result.write(oprot)
5706 
    oprot.writeMessageEnd()
5707 
    oprot.trans.flush()
5708 
 
5709 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5710 
    args = markItemAsContentComplete_args()
5711 
    args.read(iprot)
5712 
    iprot.readMessageEnd()
5713 
    result = markItemAsContentComplete_result()
5714 
    try:
9253 rajveer 5715 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5716 
    except CatalogServiceException, cex:
5717 
      result.cex = cex
5718 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5719 
    result.write(oprot)
5720 
    oprot.writeMessageEnd()
5721 
    oprot.trans.flush()
5722 
 
5723 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5724 
    args = getAllItemsInRange_args()
5725 
    args.read(iprot)
5726 
    iprot.readMessageEnd()
5727 
    result = getAllItemsInRange_result()
5728 
    try:
5729 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5730 
    except CatalogServiceException, cex:
5731 
      result.cex = cex
5732 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5733 
    result.write(oprot)
5734 
    oprot.writeMessageEnd()
5735 
    oprot.trans.flush()
5736 
 
5737 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5738 
    args = getAllItemsByStatusInRange_args()
5739 
    args.read(iprot)
5740 
    iprot.readMessageEnd()
5741 
    result = getAllItemsByStatusInRange_result()
5742 
    try:
5743 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5744 
    except CatalogServiceException, cex:
5745 
      result.cex = cex
5746 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5747 
    result.write(oprot)
5748 
    oprot.writeMessageEnd()
5749 
    oprot.trans.flush()
5750 
 
5751 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5752 
    args = getItemCountByStatus_args()
5753 
    args.read(iprot)
5754 
    iprot.readMessageEnd()
5755 
    result = getItemCountByStatus_result()
5756 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5757 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5758 
    result.write(oprot)
5759 
    oprot.writeMessageEnd()
5760 
    oprot.trans.flush()
5761 
 
5762 
  def process_getBestSellers(self, seqid, iprot, oprot):
5763 
    args = getBestSellers_args()
5764 
    args.read(iprot)
5765 
    iprot.readMessageEnd()
5766 
    result = getBestSellers_result()
5767 
    try:
5768 
      result.success = self._handler.getBestSellers()
5769 
    except CatalogServiceException, isex:
5770 
      result.isex = isex
5771 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
5776 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5777 
    args = getBestSellersCatalogIds_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = getBestSellersCatalogIds_result()
5781 
    try:
5782 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5783 
    except CatalogServiceException, cex:
5784 
      result.cex = cex
5785 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
5790 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5791 
    args = getBestSellersCount_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = getBestSellersCount_result()
5795 
    try:
5796 
      result.success = self._handler.getBestSellersCount()
5797 
    except CatalogServiceException, cex:
5798 
      result.cex = cex
5799 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
5804 
  def process_getBestDeals(self, seqid, iprot, oprot):
5805 
    args = getBestDeals_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = getBestDeals_result()
5809 
    try:
5810 
      result.success = self._handler.getBestDeals()
5811 
    except CatalogServiceException, isex:
5812 
      result.isex = isex
5813 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
5817 
 
5818 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5819 
    args = getBestDealsCatalogIds_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = getBestDealsCatalogIds_result()
5823 
    try:
5824 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5825 
    except CatalogServiceException, cex:
5826 
      result.cex = cex
5827 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5828 
    result.write(oprot)
5829 
    oprot.writeMessageEnd()
5830 
    oprot.trans.flush()
5831 
 
5832 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5833 
    args = getBestDealsCount_args()
5834 
    args.read(iprot)
5835 
    iprot.readMessageEnd()
5836 
    result = getBestDealsCount_result()
5837 
    try:
5838 
      result.success = self._handler.getBestDealsCount()
5839 
    except CatalogServiceException, cex:
5840 
      result.cex = cex
5841 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5842 
    result.write(oprot)
5843 
    oprot.writeMessageEnd()
5844 
    oprot.trans.flush()
5845 
 
5846 
  def process_getComingSoon(self, seqid, iprot, oprot):
5847 
    args = getComingSoon_args()
5848 
    args.read(iprot)
5849 
    iprot.readMessageEnd()
5850 
    result = getComingSoon_result()
5851 
    try:
5852 
      result.success = self._handler.getComingSoon()
5853 
    except CatalogServiceException, isex:
5854 
      result.isex = isex
5855 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
5860 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5861 
    args = getComingSoonCatalogIds_args()
5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
5864 
    result = getComingSoonCatalogIds_result()
5865 
    try:
5866 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5867 
    except CatalogServiceException, cex:
5868 
      result.cex = cex
5869 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
5873 
 
5874 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5875 
    args = getComingSoonCount_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = getComingSoonCount_result()
5879 
    try:
5880 
      result.success = self._handler.getComingSoonCount()
5881 
    except CatalogServiceException, cex:
5882 
      result.cex = cex
5883 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5884 
    result.write(oprot)
5885 
    oprot.writeMessageEnd()
5886 
    oprot.trans.flush()
5887 
 
5888 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5889 
    args = getLatestArrivals_args()
5890 
    args.read(iprot)
5891 
    iprot.readMessageEnd()
5892 
    result = getLatestArrivals_result()
5893 
    try:
5894 
      result.success = self._handler.getLatestArrivals()
5895 
    except CatalogServiceException, isex:
5896 
      result.isex = isex
5897 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
5901 
 
5902 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5903 
    args = getLatestArrivalsCatalogIds_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = getLatestArrivalsCatalogIds_result()
5907 
    try:
5908 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5909 
    except CatalogServiceException, cex:
5910 
      result.cex = cex
5911 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5912 
    result.write(oprot)
5913 
    oprot.writeMessageEnd()
5914 
    oprot.trans.flush()
5915 
 
5916 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5917 
    args = getLatestArrivalsCount_args()
5918 
    args.read(iprot)
5919 
    iprot.readMessageEnd()
5920 
    result = getLatestArrivalsCount_result()
5921 
    try:
5922 
      result.success = self._handler.getLatestArrivalsCount()
5923 
    except CatalogServiceException, cex:
5924 
      result.cex = cex
5925 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5926 
    result.write(oprot)
5927 
    oprot.writeMessageEnd()
5928 
    oprot.trans.flush()
5929 
 
5930 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5931 
    args = generateNewEntityID_args()
5932 
    args.read(iprot)
5933 
    iprot.readMessageEnd()
5934 
    result = generateNewEntityID_result()
5935 
    result.success = self._handler.generateNewEntityID()
5936 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5937 
    result.write(oprot)
5938 
    oprot.writeMessageEnd()
5939 
    oprot.trans.flush()
5940 
 
5941 
  def process_addCategory(self, seqid, iprot, oprot):
5942 
    args = addCategory_args()
5943 
    args.read(iprot)
5944 
    iprot.readMessageEnd()
5945 
    result = addCategory_result()
5946 
    result.success = self._handler.addCategory(args.category)
5947 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5948 
    result.write(oprot)
5949 
    oprot.writeMessageEnd()
5950 
    oprot.trans.flush()
5951 
 
5952 
  def process_getCategory(self, seqid, iprot, oprot):
5953 
    args = getCategory_args()
5954 
    args.read(iprot)
5955 
    iprot.readMessageEnd()
5956 
    result = getCategory_result()
5957 
    result.success = self._handler.getCategory(args.id)
5958 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5959 
    result.write(oprot)
5960 
    oprot.writeMessageEnd()
5961 
    oprot.trans.flush()
5962 
 
5963 
  def process_getAllCategories(self, seqid, iprot, oprot):
5964 
    args = getAllCategories_args()
5965 
    args.read(iprot)
5966 
    iprot.readMessageEnd()
5967 
    result = getAllCategories_result()
5968 
    result.success = self._handler.getAllCategories()
5969 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
5973 
 
5974 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5975 
    args = getAllSimilarItems_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = getAllSimilarItems_result()
5979 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5980 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5981 
    result.write(oprot)
5982 
    oprot.writeMessageEnd()
5983 
    oprot.trans.flush()
5984 
 
5985 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5986 
    args = addSimilarItem_args()
5987 
    args.read(iprot)
5988 
    iprot.readMessageEnd()
5989 
    result = addSimilarItem_result()
5990 
    try:
5991 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5992 
    except CatalogServiceException, cex:
5993 
      result.cex = cex
5994 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5995 
    result.write(oprot)
5996 
    oprot.writeMessageEnd()
5997 
    oprot.trans.flush()
5998 
 
6512 kshitij.so 5999 
  def process_addTag(self, seqid, iprot, oprot):
6000 
    args = addTag_args()
6001 
    args.read(iprot)
6002 
    iprot.readMessageEnd()
6003 
    result = addTag_result()
6004 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6005 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6006 
    result.write(oprot)
6007 
    oprot.writeMessageEnd()
6008 
    oprot.trans.flush()
6009 
 
6010 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6011 
    args = deleteEntityTag_args()
6012 
    args.read(iprot)
6013 
    iprot.readMessageEnd()
6014 
    result = deleteEntityTag_result()
6015 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6016 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6017 
    result.write(oprot)
6018 
    oprot.writeMessageEnd()
6019 
    oprot.trans.flush()
6020 
 
6021 
  def process_deleteTag(self, seqid, iprot, oprot):
6022 
    args = deleteTag_args()
6023 
    args.read(iprot)
6024 
    iprot.readMessageEnd()
6025 
    result = deleteTag_result()
6026 
    result.success = self._handler.deleteTag(args.displayName)
6027 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6028 
    result.write(oprot)
6029 
    oprot.writeMessageEnd()
6030 
    oprot.trans.flush()
6031 
 
6032 
  def process_getAllTags(self, seqid, iprot, oprot):
6033 
    args = getAllTags_args()
6034 
    args.read(iprot)
6035 
    iprot.readMessageEnd()
6036 
    result = getAllTags_result()
6037 
    result.success = self._handler.getAllTags()
6038 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6039 
    result.write(oprot)
6040 
    oprot.writeMessageEnd()
6041 
    oprot.trans.flush()
6042 
 
6043 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6044 
    args = getAllEntitiesByTagName_args()
6045 
    args.read(iprot)
6046 
    iprot.readMessageEnd()
6047 
    result = getAllEntitiesByTagName_result()
6048 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6049 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6050 
    result.write(oprot)
6051 
    oprot.writeMessageEnd()
6052 
    oprot.trans.flush()
6053 
 
6845 amit.gupta 6054 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6055 
    args = getAllEntityTags_args()
6056 
    args.read(iprot)
6057 
    iprot.readMessageEnd()
6058 
    result = getAllEntityTags_result()
6059 
    result.success = self._handler.getAllEntityTags()
6060 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6061 
    result.write(oprot)
6062 
    oprot.writeMessageEnd()
6063 
    oprot.trans.flush()
6064 
 
6850 kshitij.so 6065 
  def process_addBanner(self, seqid, iprot, oprot):
6066 
    args = addBanner_args()
6067 
    args.read(iprot)
6068 
    iprot.readMessageEnd()
6069 
    result = addBanner_result()
8590 kshitij.so 6070 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6071 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6072 
    result.write(oprot)
6073 
    oprot.writeMessageEnd()
6074 
    oprot.trans.flush()
6075 
 
8579 kshitij.so 6076 
  def process_updateBanner(self, seqid, iprot, oprot):
6077 
    args = updateBanner_args()
6078 
    args.read(iprot)
6079 
    iprot.readMessageEnd()
6080 
    result = updateBanner_result()
6081 
    result.success = self._handler.updateBanner(args.banner)
6082 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6083 
    result.write(oprot)
6084 
    oprot.writeMessageEnd()
6085 
    oprot.trans.flush()
6086 
 
6850 kshitij.so 6087 
  def process_getAllBanners(self, seqid, iprot, oprot):
6088 
    args = getAllBanners_args()
6089 
    args.read(iprot)
6090 
    iprot.readMessageEnd()
6091 
    result = getAllBanners_result()
6092 
    result.success = self._handler.getAllBanners()
6093 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6094 
    result.write(oprot)
6095 
    oprot.writeMessageEnd()
6096 
    oprot.trans.flush()
6097 
 
6098 
  def process_deleteBanner(self, seqid, iprot, oprot):
6099 
    args = deleteBanner_args()
6100 
    args.read(iprot)
6101 
    iprot.readMessageEnd()
6102 
    result = deleteBanner_result()
9155 kshitij.so 6103 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6104 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6105 
    result.write(oprot)
6106 
    oprot.writeMessageEnd()
6107 
    oprot.trans.flush()
6108 
 
6109 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6110 
    args = getBannerDetails_args()
6111 
    args.read(iprot)
6112 
    iprot.readMessageEnd()
6113 
    result = getBannerDetails_result()
9155 kshitij.so 6114 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6115 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6116 
    result.write(oprot)
6117 
    oprot.writeMessageEnd()
6118 
    oprot.trans.flush()
6119 
 
6120 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6121 
    args = getActiveBanners_args()
6122 
    args.read(iprot)
6123 
    iprot.readMessageEnd()
6124 
    result = getActiveBanners_result()
6125 
    result.success = self._handler.getActiveBanners()
6126 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6127 
    result.write(oprot)
6128 
    oprot.writeMessageEnd()
6129 
    oprot.trans.flush()
6130 
 
6849 kshitij.so 6131 
  def process_addBannerMap(self, seqid, iprot, oprot):
6132 
    args = addBannerMap_args()
6133 
    args.read(iprot)
6134 
    iprot.readMessageEnd()
6135 
    result = addBannerMap_result()
8579 kshitij.so 6136 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6137 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6138 
    result.write(oprot)
6139 
    oprot.writeMessageEnd()
6140 
    oprot.trans.flush()
6141 
 
8579 kshitij.so 6142 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6143 
    args = updateBannerMap_args()
6144 
    args.read(iprot)
6145 
    iprot.readMessageEnd()
6146 
    result = updateBannerMap_result()
6147 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6148 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6149 
    result.write(oprot)
6150 
    oprot.writeMessageEnd()
6151 
    oprot.trans.flush()
6152 
 
6849 kshitij.so 6153 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6154 
    args = deleteBannerMap_args()
6155 
    args.read(iprot)
6156 
    iprot.readMessageEnd()
6157 
    result = deleteBannerMap_result()
6158 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6159 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6160 
    result.write(oprot)
6161 
    oprot.writeMessageEnd()
6162 
    oprot.trans.flush()
6163 
 
6164 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6165 
    args = getBannerMapDetails_args()
6166 
    args.read(iprot)
6167 
    iprot.readMessageEnd()
6168 
    result = getBannerMapDetails_result()
9155 kshitij.so 6169 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6170 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
8579 kshitij.so 6175 
  def process_addBannerUri(self, seqid, iprot, oprot):
6176 
    args = addBannerUri_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = addBannerUri_result()
6180 
    self._handler.addBannerUri(args.bannerUriMappings)
6181 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6182 
    result.write(oprot)
6183 
    oprot.writeMessageEnd()
6184 
    oprot.trans.flush()
6185 
 
6186 
  def process_getUriMapping(self, seqid, iprot, oprot):
6187 
    args = getUriMapping_args()
6188 
    args.read(iprot)
6189 
    iprot.readMessageEnd()
6190 
    result = getUriMapping_result()
9155 kshitij.so 6191 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6192 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
6196 
 
6197 
  def process_addCampaign(self, seqid, iprot, oprot):
6198 
    args = addCampaign_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = addCampaign_result()
6202 
    self._handler.addCampaign(args.campaign)
6203 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6204 
    result.write(oprot)
6205 
    oprot.writeMessageEnd()
6206 
    oprot.trans.flush()
6207 
 
6208 
  def process_getCampaigns(self, seqid, iprot, oprot):
6209 
    args = getCampaigns_args()
6210 
    args.read(iprot)
6211 
    iprot.readMessageEnd()
6212 
    result = getCampaigns_result()
6213 
    result.success = self._handler.getCampaigns(args.campaignName)
6214 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6215 
    result.write(oprot)
6216 
    oprot.writeMessageEnd()
6217 
    oprot.trans.flush()
6218 
 
6219 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6220 
    args = deleteCampaign_args()
6221 
    args.read(iprot)
6222 
    iprot.readMessageEnd()
6223 
    result = deleteCampaign_result()
6224 
    self._handler.deleteCampaign(args.campaignId)
6225 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6226 
    result.write(oprot)
6227 
    oprot.writeMessageEnd()
6228 
    oprot.trans.flush()
6229 
 
6230 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6231 
    args = getAllCampaigns_args()
6232 
    args.read(iprot)
6233 
    iprot.readMessageEnd()
6234 
    result = getAllCampaigns_result()
6235 
    result.success = self._handler.getAllCampaigns()
6236 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6237 
    result.write(oprot)
6238 
    oprot.writeMessageEnd()
6239 
    oprot.trans.flush()
6240 
 
9155 kshitij.so 6241 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6242 
    args = getActiveBannersForMobileSite_args()
6243 
    args.read(iprot)
6244 
    iprot.readMessageEnd()
6245 
    result = getActiveBannersForMobileSite_result()
6246 
    result.success = self._handler.getActiveBannersForMobileSite()
6247 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6248 
    result.write(oprot)
6249 
    oprot.writeMessageEnd()
6250 
    oprot.trans.flush()
6251 
 
5944 mandeep.dh 6252 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6253 
    args = deleteSimilarItem_args()
6254 
    args.read(iprot)
6255 
    iprot.readMessageEnd()
6256 
    result = deleteSimilarItem_result()
6257 
    try:
6258 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6259 
    except CatalogServiceException, cex:
6260 
      result.cex = cex
6261 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6262 
    result.write(oprot)
6263 
    oprot.writeMessageEnd()
6264 
    oprot.trans.flush()
6265 
 
6266 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6267 
    args = checkSimilarItem_args()
6268 
    args.read(iprot)
6269 
    iprot.readMessageEnd()
6270 
    result = checkSimilarItem_result()
6271 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6272 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6273 
    result.write(oprot)
6274 
    oprot.writeMessageEnd()
6275 
    oprot.trans.flush()
6276 
 
6277 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6278 
    args = validateRiskyStatus_args()
6279 
    args.read(iprot)
6280 
    iprot.readMessageEnd()
6281 
    result = validateRiskyStatus_result()
6282 
    self._handler.validateRiskyStatus(args.itemId)
6283 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6284 
    result.write(oprot)
6285 
    oprot.writeMessageEnd()
6286 
    oprot.trans.flush()
6287 
 
6288 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6289 
    args = changeItemRiskyFlag_args()
6290 
    args.read(iprot)
6291 
    iprot.readMessageEnd()
6292 
    result = changeItemRiskyFlag_result()
6293 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6294 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6295 
    result.write(oprot)
6296 
    oprot.writeMessageEnd()
6297 
    oprot.trans.flush()
6298 
 
6299 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6300 
    args = getItemsByRiskyFlag_args()
6301 
    args.read(iprot)
6302 
    iprot.readMessageEnd()
6303 
    result = getItemsByRiskyFlag_result()
6304 
    result.success = self._handler.getItemsByRiskyFlag()
6305 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6306 
    result.write(oprot)
6307 
    oprot.writeMessageEnd()
6308 
    oprot.trans.flush()
6309 
 
6310 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6311 
    args = getItemsForMasterSheet_args()
6312 
    args.read(iprot)
6313 
    iprot.readMessageEnd()
6314 
    result = getItemsForMasterSheet_result()
6315 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6316 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
6320 
 
6321 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6322 
    args = getSimilarItemsCatalogIds_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = getSimilarItemsCatalogIds_result()
6326 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6327 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6328 
    result.write(oprot)
6329 
    oprot.writeMessageEnd()
6330 
    oprot.trans.flush()
6331 
 
6332 
  def process_addProductNotification(self, seqid, iprot, oprot):
6333 
    args = addProductNotification_args()
6334 
    args.read(iprot)
6335 
    iprot.readMessageEnd()
6336 
    result = addProductNotification_result()
6337 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6338 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
6342 
 
6343 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6344 
    args = sendProductNotifications_args()
6345 
    args.read(iprot)
6346 
    iprot.readMessageEnd()
6347 
    result = sendProductNotifications_result()
6348 
    result.success = self._handler.sendProductNotifications()
6349 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6350 
    result.write(oprot)
6351 
    oprot.writeMessageEnd()
6352 
    oprot.trans.flush()
6353 
 
6354 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6355 
    args = getAllBrandsByCategory_args()
6356 
    args.read(iprot)
6357 
    iprot.readMessageEnd()
6358 
    result = getAllBrandsByCategory_result()
6359 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6360 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6361 
    result.write(oprot)
6362 
    oprot.writeMessageEnd()
6363 
    oprot.trans.flush()
6364 
 
6365 
  def process_getAllBrands(self, seqid, iprot, oprot):
6366 
    args = getAllBrands_args()
6367 
    args.read(iprot)
6368 
    iprot.readMessageEnd()
6369 
    result = getAllBrands_result()
6370 
    result.success = self._handler.getAllBrands()
6371 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6372 
    result.write(oprot)
6373 
    oprot.writeMessageEnd()
6374 
    oprot.trans.flush()
6375 
 
6376 
  def process_getAllSources(self, seqid, iprot, oprot):
6377 
    args = getAllSources_args()
6378 
    args.read(iprot)
6379 
    iprot.readMessageEnd()
6380 
    result = getAllSources_result()
6381 
    result.success = self._handler.getAllSources()
6382 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
6386 
 
6387 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6388 
    args = getItemPricingBySource_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = getItemPricingBySource_result()
6392 
    try:
6393 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6394 
    except CatalogServiceException, cex:
6395 
      result.cex = cex
6396 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
6400 
 
6401 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6402 
    args = addSourceItemPricing_args()
6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
6405 
    result = addSourceItemPricing_result()
6406 
    try:
6407 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6408 
    except CatalogServiceException, cex:
6409 
      result.cex = cex
6410 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
6414 
 
6415 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6416 
    args = getAllSourcePricing_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = getAllSourcePricing_result()
6420 
    try:
6421 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6422 
    except CatalogServiceException, cex:
6423 
      result.cex = cex
6424 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6425 
    result.write(oprot)
6426 
    oprot.writeMessageEnd()
6427 
    oprot.trans.flush()
6428 
 
6429 
  def process_getItemForSource(self, seqid, iprot, oprot):
6430 
    args = getItemForSource_args()
6431 
    args.read(iprot)
6432 
    iprot.readMessageEnd()
6433 
    result = getItemForSource_result()
6434 
    try:
6435 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6436 
    except CatalogServiceException, cex:
6437 
      result.cex = cex
6438 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
6442 
 
6443 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6444 
    args = searchItemsInRange_args()
6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
6447 
    result = searchItemsInRange_result()
6448 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6449 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6450 
    result.write(oprot)
6451 
    oprot.writeMessageEnd()
6452 
    oprot.trans.flush()
6453 
 
6454 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6455 
    args = getSearchResultCount_args()
6456 
    args.read(iprot)
6457 
    iprot.readMessageEnd()
6458 
    result = getSearchResultCount_result()
6459 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6460 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6461 
    result.write(oprot)
6462 
    oprot.writeMessageEnd()
6463 
    oprot.trans.flush()
6464 
 
6465 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6466 
    args = getProductNotifications_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = getProductNotifications_result()
6470 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6471 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6472 
    result.write(oprot)
6473 
    oprot.writeMessageEnd()
6474 
    oprot.trans.flush()
6475 
 
6476 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6477 
    args = getProductNotificationRequestCount_args()
6478 
    args.read(iprot)
6479 
    iprot.readMessageEnd()
6480 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6481 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6482 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6483 
    result.write(oprot)
6484 
    oprot.writeMessageEnd()
6485 
    oprot.trans.flush()
6486 
 
6487 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6488 
    args = addAuthorizationLog_args()
6489 
    args.read(iprot)
6490 
    iprot.readMessageEnd()
6491 
    result = addAuthorizationLog_result()
6492 
    try:
6493 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6494 
    except CatalogServiceException, cex:
6495 
      result.cex = cex
6496 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6497 
    result.write(oprot)
6498 
    oprot.writeMessageEnd()
6499 
    oprot.trans.flush()
6500 
 
6501 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6502 
    args = addupdateVoucherForItem_args()
6503 
    args.read(iprot)
6504 
    iprot.readMessageEnd()
6505 
    result = addupdateVoucherForItem_result()
6506 
    try:
6507 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6508 
    except CatalogServiceException, cex:
6509 
      result.cex = cex
6510 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6511 
    result.write(oprot)
6512 
    oprot.writeMessageEnd()
6513 
    oprot.trans.flush()
6514 
 
6515 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6516 
    args = deleteVoucherForItem_args()
6517 
    args.read(iprot)
6518 
    iprot.readMessageEnd()
6519 
    result = deleteVoucherForItem_result()
6520 
    try:
6521 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6522 
    except CatalogServiceException, cex:
6523 
      result.cex = cex
6524 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6525 
    result.write(oprot)
6526 
    oprot.writeMessageEnd()
6527 
    oprot.trans.flush()
6528 
 
6529 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6530 
    args = getVoucherAmount_args()
6531 
    args.read(iprot)
6532 
    iprot.readMessageEnd()
6533 
    result = getVoucherAmount_result()
6534 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6535 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6536 
    result.write(oprot)
6537 
    oprot.writeMessageEnd()
6538 
    oprot.trans.flush()
6539 
 
6540 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6541 
    args = getAllItemVouchers_args()
6542 
    args.read(iprot)
6543 
    iprot.readMessageEnd()
6544 
    result = getAllItemVouchers_result()
6545 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6546 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6551 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6552 
    args = isValidCatalogItemId_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = isValidCatalogItemId_result()
6556 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6557 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6558 
    result.write(oprot)
6559 
    oprot.writeMessageEnd()
6560 
    oprot.trans.flush()
6561 
 
6039 amit.gupta 6562 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6563 
    args = getVatPercentageForItem_args()
6564 
    args.read(iprot)
6565 
    iprot.readMessageEnd()
6566 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6567 
    try:
6568 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6569 
    except CatalogServiceException, cex:
6570 
      result.cex = cex
6039 amit.gupta 6571 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
5944 mandeep.dh 6575 
 
6039 amit.gupta 6576 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6577 
    args = getVatAmountForItem_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getVatAmountForItem_result()
6581 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6582 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
6531 vikram.rag 6587 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6588 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6592 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6593 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6039 amit.gupta 6597 
 
6821 amar.kumar 6598 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6599 
    args = getAllAliveItems_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getAllAliveItems_result()
6603 
    result.success = self._handler.getAllAliveItems()
6604 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
6608 
 
6805 anupam.sin 6609 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6610 
    args = getInsuranceAmount_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = getInsuranceAmount_result()
6921 anupam.sin 6614 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6615 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
6531 vikram.rag 6619 
 
6805 anupam.sin 6620 
  def process_getInsurer(self, seqid, iprot, oprot):
6621 
    args = getInsurer_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = getInsurer_result()
6625 
    result.success = self._handler.getInsurer(args.insurerId)
6626 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6838 vikram.rag 6631 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6632 
    args = getAllInsurers_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getAllInsurers_result()
6636 
    result.success = self._handler.getAllInsurers()
6637 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6805 anupam.sin 6641 
 
6962 rajveer 6642 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6643 
    args = updateInsuranceDeclaredAmount_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = updateInsuranceDeclaredAmount_result()
6647 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6648 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6649 
    result.write(oprot)
6650 
    oprot.writeMessageEnd()
6651 
    oprot.trans.flush()
6838 vikram.rag 6652 
 
7190 amar.kumar 6653 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6654 
    args = getFreebieForItem_args()
6655 
    args.read(iprot)
6656 
    iprot.readMessageEnd()
6657 
    result = getFreebieForItem_result()
6658 
    result.success = self._handler.getFreebieForItem(args.itemId)
6659 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6660 
    result.write(oprot)
6661 
    oprot.writeMessageEnd()
6662 
    oprot.trans.flush()
6962 rajveer 6663 
 
7190 amar.kumar 6664 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6665 
    args = addOrUpdateFreebieForItem_args()
6666 
    args.read(iprot)
6667 
    iprot.readMessageEnd()
6668 
    result = addOrUpdateFreebieForItem_result()
6669 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6670 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
7272 amit.gupta 6675 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6676 
    args = addOrUpdateBrandInfo_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = addOrUpdateBrandInfo_result()
6680 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6681 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6685 
 
6686 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6687 
    args = getBrandInfo_args()
6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
6690 
    result = getBrandInfo_result()
6691 
    result.success = self._handler.getBrandInfo()
6692 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6693 
    result.write(oprot)
6694 
    oprot.writeMessageEnd()
6695 
    oprot.trans.flush()
6696 
 
7256 rajveer 6697 
  def process_getStorePricing(self, seqid, iprot, oprot):
6698 
    args = getStorePricing_args()
6699 
    args.read(iprot)
6700 
    iprot.readMessageEnd()
6701 
    result = getStorePricing_result()
6702 
    result.success = self._handler.getStorePricing(args.itemId)
6703 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6704 
    result.write(oprot)
6705 
    oprot.writeMessageEnd()
6706 
    oprot.trans.flush()
7190 amar.kumar 6707 
 
7306 rajveer 6708 
  def process_getStorePricings(self, seqid, iprot, oprot):
6709 
    args = getStorePricings_args()
6710 
    args.read(iprot)
6711 
    iprot.readMessageEnd()
6712 
    result = getStorePricings_result()
6713 
    result.success = self._handler.getStorePricings(args.itemIds)
6714 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
6718 
 
7265 rajveer 6719 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6720 
    args = updateStorePricing_args()
6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
6723 
    result = updateStorePricing_result()
7382 rajveer 6724 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6725 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
7256 rajveer 6729 
 
7281 kshitij.so 6730 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6731 
    args = getAllAmazonListedItems_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getAllAmazonListedItems_result()
6735 
    result.success = self._handler.getAllAmazonListedItems()
6736 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
7265 rajveer 6740 
 
8619 kshitij.so 6741 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6742 
    args = searchAmazonItems_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = searchAmazonItems_result()
6746 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6747 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
6752 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6753 
    args = getAmazonSearchResultCount_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = getAmazonSearchResultCount_result()
6757 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6758 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6759 
    result.write(oprot)
6760 
    oprot.writeMessageEnd()
6761 
    oprot.trans.flush()
6762 
 
6763 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6764 
    args = getCountForAmazonlistedItems_args()
6765 
    args.read(iprot)
6766 
    iprot.readMessageEnd()
6767 
    result = getCountForAmazonlistedItems_result()
6768 
    result.success = self._handler.getCountForAmazonlistedItems()
6769 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
6773 
 
7281 kshitij.so 6774 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6775 
    args = getAmazonItemDetails_args()
6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
6778 
    result = getAmazonItemDetails_result()
6779 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6780 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
6784 
 
6785 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6786 
    args = updateAmazonItemDetails_args()
6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
6789 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6790 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6791 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6792 
    result.write(oprot)
6793 
    oprot.writeMessageEnd()
6794 
    oprot.trans.flush()
6795 
 
6796 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6797 
    args = addAmazonItem_args()
6798 
    args.read(iprot)
6799 
    iprot.readMessageEnd()
6800 
    result = addAmazonItem_result()
6801 
    self._handler.addAmazonItem(args.amazonlisted)
6802 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6803 
    result.write(oprot)
6804 
    oprot.writeMessageEnd()
6805 
    oprot.trans.flush()
6806 
 
7291 vikram.rag 6807 
  def process_getAsinItems(self, seqid, iprot, oprot):
6808 
    args = getAsinItems_args()
6809 
    args.read(iprot)
6810 
    iprot.readMessageEnd()
6811 
    result = getAsinItems_result()
6812 
    result.success = self._handler.getAsinItems()
6813 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6814 
    result.write(oprot)
6815 
    oprot.writeMessageEnd()
6816 
    oprot.trans.flush()
7281 kshitij.so 6817 
 
7291 vikram.rag 6818 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6819 
    args = getAllFbaListedItems_args()
6820 
    args.read(iprot)
6821 
    iprot.readMessageEnd()
6822 
    result = getAllFbaListedItems_result()
6823 
    result.success = self._handler.getAllFbaListedItems()
6824 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6825 
    result.write(oprot)
6826 
    oprot.writeMessageEnd()
6827 
    oprot.trans.flush()
6828 
 
6829 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6830 
    args = getAllNonFbaListedItems_args()
6831 
    args.read(iprot)
6832 
    iprot.readMessageEnd()
6833 
    result = getAllNonFbaListedItems_result()
6834 
    result.success = self._handler.getAllNonFbaListedItems()
6835 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6836 
    result.write(oprot)
6837 
    oprot.writeMessageEnd()
6838 
    oprot.trans.flush()
6839 
 
7460 kshitij.so 6840 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6841 
    args = updateItemInventory_args()
6842 
    args.read(iprot)
6843 
    iprot.readMessageEnd()
6844 
    result = updateItemInventory_result()
6845 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6846 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6847 
    result.write(oprot)
6848 
    oprot.writeMessageEnd()
6849 
    oprot.trans.flush()
7291 vikram.rag 6850 
 
7770 kshitij.so 6851 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6852 
    args = updateTimestampForAmazonFeeds_args()
6853 
    args.read(iprot)
6854 
    iprot.readMessageEnd()
6855 
    result = updateTimestampForAmazonFeeds_result()
6856 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6857 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6858 
    result.write(oprot)
6859 
    oprot.writeMessageEnd()
6860 
    oprot.trans.flush()
7460 kshitij.so 6861 
 
7897 amar.kumar 6862 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6863 
    args = getAllParentCategories_args()
6864 
    args.read(iprot)
6865 
    iprot.readMessageEnd()
6866 
    result = getAllParentCategories_result()
6867 
    result.success = self._handler.getAllParentCategories()
6868 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6869 
    result.write(oprot)
6870 
    oprot.writeMessageEnd()
6871 
    oprot.trans.flush()
7770 kshitij.so 6872 
 
7977 kshitij.so 6873 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6874 
    args = addPageViewEvent_args()
6875 
    args.read(iprot)
6876 
    iprot.readMessageEnd()
6877 
    result = addPageViewEvent_result()
6878 
    self._handler.addPageViewEvent(args.pageViewEvents)
6879 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6880 
    result.write(oprot)
6881 
    oprot.writeMessageEnd()
6882 
    oprot.trans.flush()
7897 amar.kumar 6883 
 
7977 kshitij.so 6884 
  def process_addCartEvent(self, seqid, iprot, oprot):
6885 
    args = addCartEvent_args()
6886 
    args.read(iprot)
6887 
    iprot.readMessageEnd()
6888 
    result = addCartEvent_result()
6889 
    self._handler.addCartEvent(args.cartEvents)
6890 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6891 
    result.write(oprot)
6892 
    oprot.writeMessageEnd()
6893 
    oprot.trans.flush()
6894 
 
8182 amar.kumar 6895 
  def process_addEbayItem(self, seqid, iprot, oprot):
6896 
    args = addEbayItem_args()
6897 
    args.read(iprot)
6898 
    iprot.readMessageEnd()
6899 
    result = addEbayItem_result()
6900 
    self._handler.addEbayItem(args.ebayItem)
6901 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6902 
    result.write(oprot)
6903 
    oprot.writeMessageEnd()
6904 
    oprot.trans.flush()
6905 
 
6906 
  def process_getEbayItem(self, seqid, iprot, oprot):
6907 
    args = getEbayItem_args()
6908 
    args.read(iprot)
6909 
    iprot.readMessageEnd()
6910 
    result = getEbayItem_result()
6911 
    result.success = self._handler.getEbayItem(args.listingId)
6912 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6913 
    result.write(oprot)
6914 
    oprot.writeMessageEnd()
6915 
    oprot.trans.flush()
6916 
 
6917 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6918 
    args = updateEbayItem_args()
6919 
    args.read(iprot)
6920 
    iprot.readMessageEnd()
6921 
    result = updateEbayItem_result()
6922 
    self._handler.updateEbayItem(args.ebayItem)
6923 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6924 
    result.write(oprot)
6925 
    oprot.writeMessageEnd()
6926 
    oprot.trans.flush()
6927 
 
8139 kshitij.so 6928 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6929 
    args = getAmazonListedItems_args()
6930 
    args.read(iprot)
6931 
    iprot.readMessageEnd()
6932 
    result = getAmazonListedItems_result()
6933 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6934 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
7977 kshitij.so 6938 
 
8168 kshitij.so 6939 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6940 
    args = updateAmazonAttributesInBulk_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = updateAmazonAttributesInBulk_result()
6944 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6945 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6946 
    result.write(oprot)
6947 
    oprot.writeMessageEnd()
6948 
    oprot.trans.flush()
8139 kshitij.so 6949 
 
8379 vikram.rag 6950 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6951 
    args = getAllItemstoListOnFba_args()
6952 
    args.read(iprot)
6953 
    iprot.readMessageEnd()
6954 
    result = getAllItemstoListOnFba_result()
6955 
    result.success = self._handler.getAllItemstoListOnFba()
6956 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6957 
    result.write(oprot)
6958 
    oprot.writeMessageEnd()
6959 
    oprot.trans.flush()
8168 kshitij.so 6960 
 
8379 vikram.rag 6961 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6962 
    args = getAllItemstoListOnNonFba_args()
6963 
    args.read(iprot)
6964 
    iprot.readMessageEnd()
6965 
    result = getAllItemstoListOnNonFba_result()
6966 
    result.success = self._handler.getAllItemstoListOnNonFba()
6967 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6968 
    result.write(oprot)
6969 
    oprot.writeMessageEnd()
6970 
    oprot.trans.flush()
6971 
 
8619 kshitij.so 6972 
  def process_updateAsin(self, seqid, iprot, oprot):
6973 
    args = updateAsin_args()
6974 
    args.read(iprot)
6975 
    iprot.readMessageEnd()
6976 
    result = updateAsin_result()
6977 
    self._handler.updateAsin(args.item)
6978 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
8616 vikram.rag 6982 
 
8739 vikram.rag 6983 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6984 
    args = addOrUpdateSnapdealItem_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = addOrUpdateSnapdealItem_result()
6988 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6989 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
8619 kshitij.so 6993 
 
8739 vikram.rag 6994 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6995 
    args = getSnapdealItem_args()
6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
6998 
    result = getSnapdealItem_result()
6999 
    result.success = self._handler.getSnapdealItem(args.item_id)
7000 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7001 
    result.write(oprot)
7002 
    oprot.writeMessageEnd()
7003 
    oprot.trans.flush()
7004 
 
9242 kshitij.so 7005 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7006 
    args = getSnapdealItemDetails_args()
7007 
    args.read(iprot)
7008 
    iprot.readMessageEnd()
7009 
    result = getSnapdealItemDetails_result()
7010 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7011 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7012 
    result.write(oprot)
7013 
    oprot.writeMessageEnd()
7014 
    oprot.trans.flush()
7015 
 
8739 vikram.rag 7016 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7017 
    args = getAllSnapdealItems_args()
7018 
    args.read(iprot)
7019 
    iprot.readMessageEnd()
7020 
    result = getAllSnapdealItems_result()
7021 
    result.success = self._handler.getAllSnapdealItems()
7022 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7023 
    result.write(oprot)
7024 
    oprot.writeMessageEnd()
7025 
    oprot.trans.flush()
7026 
 
9242 kshitij.so 7027 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7028 
    args = getSnapdealItems_args()
7029 
    args.read(iprot)
7030 
    iprot.readMessageEnd()
7031 
    result = getSnapdealItems_result()
7032 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7033 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7034 
    result.write(oprot)
7035 
    oprot.writeMessageEnd()
7036 
    oprot.trans.flush()
8739 vikram.rag 7037 
 
9242 kshitij.so 7038 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7039 
    args = searchSnapdealItems_args()
7040 
    args.read(iprot)
7041 
    iprot.readMessageEnd()
7042 
    result = searchSnapdealItems_result()
7043 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7044 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7045 
    result.write(oprot)
7046 
    oprot.writeMessageEnd()
7047 
    oprot.trans.flush()
7048 
 
7049 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7050 
    args = getCountForSnapdealItems_args()
7051 
    args.read(iprot)
7052 
    iprot.readMessageEnd()
7053 
    result = getCountForSnapdealItems_result()
7054 
    result.success = self._handler.getCountForSnapdealItems()
7055 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7056 
    result.write(oprot)
7057 
    oprot.writeMessageEnd()
7058 
    oprot.trans.flush()
7059 
 
7060 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7061 
    args = getSnapdealSearchResultCount_args()
7062 
    args.read(iprot)
7063 
    iprot.readMessageEnd()
7064 
    result = getSnapdealSearchResultCount_result()
7065 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7066 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7067 
    result.write(oprot)
7068 
    oprot.writeMessageEnd()
7069 
    oprot.trans.flush()
7070 
 
9299 kshitij.so 7071 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7072 
    args = getPrefferedInsurerForItem_args()
7073 
    args.read(iprot)
7074 
    iprot.readMessageEnd()
7075 
    result = getPrefferedInsurerForItem_result()
7076 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7077 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7078 
    result.write(oprot)
7079 
    oprot.writeMessageEnd()
7080 
    oprot.trans.flush()
9242 kshitij.so 7081 
 
9456 vikram.rag 7082 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7083 
    args = getSnapdealItembySkuAtSnapdeal_args()
7084 
    args.read(iprot)
7085 
    iprot.readMessageEnd()
7086 
    result = getSnapdealItembySkuAtSnapdeal_result()
7087 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7088 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7089 
    result.write(oprot)
7090 
    oprot.writeMessageEnd()
7091 
    oprot.trans.flush()
9299 kshitij.so 7092 
 
9621 manish.sha 7093 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7094 
    args = getProductFeedSubmit_args()
7095 
    args.read(iprot)
7096 
    iprot.readMessageEnd()
7097 
    result = getProductFeedSubmit_result()
7098 
    try:
7099 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7100 
    except CatalogServiceException, cex:
7101 
      result.cex = cex
7102 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7103 
    result.write(oprot)
7104 
    oprot.writeMessageEnd()
7105 
    oprot.trans.flush()
9456 vikram.rag 7106 
 
9621 manish.sha 7107 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7108 
    args = addProductFeedSubmit_args()
7109 
    args.read(iprot)
7110 
    iprot.readMessageEnd()
7111 
    result = addProductFeedSubmit_result()
7112 
    try:
7113 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7114 
    except CatalogServiceException, cex:
7115 
      result.cex = cex
7116 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7117 
    result.write(oprot)
7118 
    oprot.writeMessageEnd()
7119 
    oprot.trans.flush()
7120 
 
7121 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7122 
    args = updateProductFeedSubmit_args()
7123 
    args.read(iprot)
7124 
    iprot.readMessageEnd()
7125 
    result = updateProductFeedSubmit_result()
7126 
    try:
7127 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7128 
    except CatalogServiceException, cex:
7129 
      result.cex = cex
7130 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7131 
    result.write(oprot)
7132 
    oprot.writeMessageEnd()
7133 
    oprot.trans.flush()
7134 
 
7135 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7136 
    args = deleteProductFeedSubmit_args()
7137 
    args.read(iprot)
7138 
    iprot.readMessageEnd()
7139 
    result = deleteProductFeedSubmit_result()
7140 
    try:
7141 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7142 
    except CatalogServiceException, cex:
7143 
      result.cex = cex
7144 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7145 
    result.write(oprot)
7146 
    oprot.writeMessageEnd()
7147 
    oprot.trans.flush()
7148 
 
7149 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7150 
    args = getAllProductFeedSubmit_args()
7151 
    args.read(iprot)
7152 
    iprot.readMessageEnd()
7153 
    result = getAllProductFeedSubmit_result()
7154 
    try:
7155 
      result.success = self._handler.getAllProductFeedSubmit()
7156 
    except CatalogServiceException, cex:
7157 
      result.cex = cex
7158 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7159 
    result.write(oprot)
7160 
    oprot.writeMessageEnd()
7161 
    oprot.trans.flush()
7162 
 
9724 kshitij.so 7163 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7164 
    args = getMarketplacedetailsForItem_args()
7165 
    args.read(iprot)
7166 
    iprot.readMessageEnd()
7167 
    result = getMarketplacedetailsForItem_result()
7168 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7169 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7170 
    result.write(oprot)
7171 
    oprot.writeMessageEnd()
7172 
    oprot.trans.flush()
9621 manish.sha 7173 
 
9724 kshitij.so 7174 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7175 
    args = updateMarketplaceAttributesForItem_args()
7176 
    args.read(iprot)
7177 
    iprot.readMessageEnd()
7178 
    result = updateMarketplaceAttributesForItem_result()
7179 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7180 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7181 
    result.write(oprot)
7182 
    oprot.writeMessageEnd()
7183 
    oprot.trans.flush()
7184 
 
9776 vikram.rag 7185 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7186 
    args = getMarketPlaceItemsForPriceUpdate_args()
7187 
    args.read(iprot)
7188 
    iprot.readMessageEnd()
7189 
    result = getMarketPlaceItemsForPriceUpdate_result()
7190 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7191 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7192 
    result.write(oprot)
7193 
    oprot.writeMessageEnd()
7194 
    oprot.trans.flush()
9724 kshitij.so 7195 
 
9776 vikram.rag 7196 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7197 
    args = updateMarketPlacePriceUpdateStatus_args()
7198 
    args.read(iprot)
7199 
    iprot.readMessageEnd()
7200 
    result = updateMarketPlacePriceUpdateStatus_result()
7201 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp)
7202 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7203 
    result.write(oprot)
7204 
    oprot.writeMessageEnd()
7205 
    oprot.trans.flush()
7206 
 
7207 
 
5944 mandeep.dh 7208 
# HELPER FUNCTIONS AND STRUCTURES
7209 
 
7210 
class addItem_args:
7211 
  """
7212 
  Attributes:
7213 
   - item
7214 
  """
7215 
 
7216 
  thrift_spec = (
7217 
    None, # 0
7218 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7219 
  )
7220 
 
7221 
  def __init__(self, item=None,):
7222 
    self.item = item
7223 
 
7224 
  def read(self, iprot):
7225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7227 
      return
7228 
    iprot.readStructBegin()
7229 
    while True:
7230 
      (fname, ftype, fid) = iprot.readFieldBegin()
7231 
      if ftype == TType.STOP:
7232 
        break
7233 
      if fid == 1:
7234 
        if ftype == TType.STRUCT:
7235 
          self.item = Item()
7236 
          self.item.read(iprot)
7237 
        else:
7238 
          iprot.skip(ftype)
7239 
      else:
7240 
        iprot.skip(ftype)
7241 
      iprot.readFieldEnd()
7242 
    iprot.readStructEnd()
7243 
 
7244 
  def write(self, oprot):
7245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7247 
      return
7248 
    oprot.writeStructBegin('addItem_args')
7249 
    if self.item is not None:
7250 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7251 
      self.item.write(oprot)
7252 
      oprot.writeFieldEnd()
7253 
    oprot.writeFieldStop()
7254 
    oprot.writeStructEnd()
7255 
 
7256 
  def validate(self):
7257 
    return
7258 
 
7259 
 
7260 
  def __repr__(self):
7261 
    L = ['%s=%r' % (key, value)
7262 
      for key, value in self.__dict__.iteritems()]
7263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7264 
 
7265 
  def __eq__(self, other):
7266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7267 
 
7268 
  def __ne__(self, other):
7269 
    return not (self == other)
7270 
 
7271 
class addItem_result:
7272 
  """
7273 
  Attributes:
7274 
   - success
7275 
   - cex
7276 
  """
7277 
 
7278 
  thrift_spec = (
7279 
    (0, TType.I64, 'success', None, None, ), # 0
7280 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7281 
  )
7282 
 
7283 
  def __init__(self, success=None, cex=None,):
7284 
    self.success = success
7285 
    self.cex = cex
7286 
 
7287 
  def read(self, iprot):
7288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7290 
      return
7291 
    iprot.readStructBegin()
7292 
    while True:
7293 
      (fname, ftype, fid) = iprot.readFieldBegin()
7294 
      if ftype == TType.STOP:
7295 
        break
7296 
      if fid == 0:
7297 
        if ftype == TType.I64:
7298 
          self.success = iprot.readI64();
7299 
        else:
7300 
          iprot.skip(ftype)
7301 
      elif fid == 1:
7302 
        if ftype == TType.STRUCT:
7303 
          self.cex = CatalogServiceException()
7304 
          self.cex.read(iprot)
7305 
        else:
7306 
          iprot.skip(ftype)
7307 
      else:
7308 
        iprot.skip(ftype)
7309 
      iprot.readFieldEnd()
7310 
    iprot.readStructEnd()
7311 
 
7312 
  def write(self, oprot):
7313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7315 
      return
7316 
    oprot.writeStructBegin('addItem_result')
7317 
    if self.success is not None:
7318 
      oprot.writeFieldBegin('success', TType.I64, 0)
7319 
      oprot.writeI64(self.success)
7320 
      oprot.writeFieldEnd()
7321 
    if self.cex is not None:
7322 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7323 
      self.cex.write(oprot)
7324 
      oprot.writeFieldEnd()
7325 
    oprot.writeFieldStop()
7326 
    oprot.writeStructEnd()
7327 
 
7328 
  def validate(self):
7329 
    return
7330 
 
7331 
 
7332 
  def __repr__(self):
7333 
    L = ['%s=%r' % (key, value)
7334 
      for key, value in self.__dict__.iteritems()]
7335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7336 
 
7337 
  def __eq__(self, other):
7338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7339 
 
7340 
  def __ne__(self, other):
7341 
    return not (self == other)
7342 
 
7343 
class updateItem_args:
7344 
  """
7345 
  Attributes:
7346 
   - item
7347 
  """
7348 
 
7349 
  thrift_spec = (
7350 
    None, # 0
7351 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7352 
  )
7353 
 
7354 
  def __init__(self, item=None,):
7355 
    self.item = item
7356 
 
7357 
  def read(self, iprot):
7358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7360 
      return
7361 
    iprot.readStructBegin()
7362 
    while True:
7363 
      (fname, ftype, fid) = iprot.readFieldBegin()
7364 
      if ftype == TType.STOP:
7365 
        break
7366 
      if fid == 1:
7367 
        if ftype == TType.STRUCT:
7368 
          self.item = Item()
7369 
          self.item.read(iprot)
7370 
        else:
7371 
          iprot.skip(ftype)
7372 
      else:
7373 
        iprot.skip(ftype)
7374 
      iprot.readFieldEnd()
7375 
    iprot.readStructEnd()
7376 
 
7377 
  def write(self, oprot):
7378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7380 
      return
7381 
    oprot.writeStructBegin('updateItem_args')
7382 
    if self.item is not None:
7383 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7384 
      self.item.write(oprot)
7385 
      oprot.writeFieldEnd()
7386 
    oprot.writeFieldStop()
7387 
    oprot.writeStructEnd()
7388 
 
7389 
  def validate(self):
7390 
    return
7391 
 
7392 
 
7393 
  def __repr__(self):
7394 
    L = ['%s=%r' % (key, value)
7395 
      for key, value in self.__dict__.iteritems()]
7396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7397 
 
7398 
  def __eq__(self, other):
7399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7400 
 
7401 
  def __ne__(self, other):
7402 
    return not (self == other)
7403 
 
7404 
class updateItem_result:
7405 
  """
7406 
  Attributes:
7407 
   - success
7408 
   - cex
7409 
  """
7410 
 
7411 
  thrift_spec = (
7412 
    (0, TType.I64, 'success', None, None, ), # 0
7413 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7414 
  )
7415 
 
7416 
  def __init__(self, success=None, cex=None,):
7417 
    self.success = success
7418 
    self.cex = cex
7419 
 
7420 
  def read(self, iprot):
7421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7423 
      return
7424 
    iprot.readStructBegin()
7425 
    while True:
7426 
      (fname, ftype, fid) = iprot.readFieldBegin()
7427 
      if ftype == TType.STOP:
7428 
        break
7429 
      if fid == 0:
7430 
        if ftype == TType.I64:
7431 
          self.success = iprot.readI64();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      elif fid == 1:
7435 
        if ftype == TType.STRUCT:
7436 
          self.cex = CatalogServiceException()
7437 
          self.cex.read(iprot)
7438 
        else:
7439 
          iprot.skip(ftype)
7440 
      else:
7441 
        iprot.skip(ftype)
7442 
      iprot.readFieldEnd()
7443 
    iprot.readStructEnd()
7444 
 
7445 
  def write(self, oprot):
7446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7448 
      return
7449 
    oprot.writeStructBegin('updateItem_result')
7450 
    if self.success is not None:
7451 
      oprot.writeFieldBegin('success', TType.I64, 0)
7452 
      oprot.writeI64(self.success)
7453 
      oprot.writeFieldEnd()
7454 
    if self.cex is not None:
7455 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7456 
      self.cex.write(oprot)
7457 
      oprot.writeFieldEnd()
7458 
    oprot.writeFieldStop()
7459 
    oprot.writeStructEnd()
7460 
 
7461 
  def validate(self):
7462 
    return
7463 
 
7464 
 
7465 
  def __repr__(self):
7466 
    L = ['%s=%r' % (key, value)
7467 
      for key, value in self.__dict__.iteritems()]
7468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7469 
 
7470 
  def __eq__(self, other):
7471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7472 
 
7473 
  def __ne__(self, other):
7474 
    return not (self == other)
7475 
 
7476 
class isActive_args:
7477 
  """
7478 
  Attributes:
7479 
   - itemId
7480 
  """
7481 
 
7482 
  thrift_spec = (
7483 
    None, # 0
7484 
    (1, TType.I64, 'itemId', None, None, ), # 1
7485 
  )
7486 
 
7487 
  def __init__(self, itemId=None,):
7488 
    self.itemId = itemId
7489 
 
7490 
  def read(self, iprot):
7491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7493 
      return
7494 
    iprot.readStructBegin()
7495 
    while True:
7496 
      (fname, ftype, fid) = iprot.readFieldBegin()
7497 
      if ftype == TType.STOP:
7498 
        break
7499 
      if fid == 1:
7500 
        if ftype == TType.I64:
7501 
          self.itemId = iprot.readI64();
7502 
        else:
7503 
          iprot.skip(ftype)
7504 
      else:
7505 
        iprot.skip(ftype)
7506 
      iprot.readFieldEnd()
7507 
    iprot.readStructEnd()
7508 
 
7509 
  def write(self, oprot):
7510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7512 
      return
7513 
    oprot.writeStructBegin('isActive_args')
7514 
    if self.itemId is not None:
7515 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7516 
      oprot.writeI64(self.itemId)
7517 
      oprot.writeFieldEnd()
7518 
    oprot.writeFieldStop()
7519 
    oprot.writeStructEnd()
7520 
 
7521 
  def validate(self):
7522 
    return
7523 
 
7524 
 
7525 
  def __repr__(self):
7526 
    L = ['%s=%r' % (key, value)
7527 
      for key, value in self.__dict__.iteritems()]
7528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7529 
 
7530 
  def __eq__(self, other):
7531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7532 
 
7533 
  def __ne__(self, other):
7534 
    return not (self == other)
7535 
 
7536 
class isActive_result:
7537 
  """
7538 
  Attributes:
7539 
   - success
7540 
   - isex
7541 
  """
7542 
 
7543 
  thrift_spec = (
7544 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7545 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7546 
  )
7547 
 
7548 
  def __init__(self, success=None, isex=None,):
7549 
    self.success = success
7550 
    self.isex = isex
7551 
 
7552 
  def read(self, iprot):
7553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7555 
      return
7556 
    iprot.readStructBegin()
7557 
    while True:
7558 
      (fname, ftype, fid) = iprot.readFieldBegin()
7559 
      if ftype == TType.STOP:
7560 
        break
7561 
      if fid == 0:
7562 
        if ftype == TType.STRUCT:
7563 
          self.success = ItemShippingInfo()
7564 
          self.success.read(iprot)
7565 
        else:
7566 
          iprot.skip(ftype)
7567 
      elif fid == 1:
7568 
        if ftype == TType.STRUCT:
7569 
          self.isex = CatalogServiceException()
7570 
          self.isex.read(iprot)
7571 
        else:
7572 
          iprot.skip(ftype)
7573 
      else:
7574 
        iprot.skip(ftype)
7575 
      iprot.readFieldEnd()
7576 
    iprot.readStructEnd()
7577 
 
7578 
  def write(self, oprot):
7579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7581 
      return
7582 
    oprot.writeStructBegin('isActive_result')
7583 
    if self.success is not None:
7584 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7585 
      self.success.write(oprot)
7586 
      oprot.writeFieldEnd()
7587 
    if self.isex is not None:
7588 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7589 
      self.isex.write(oprot)
7590 
      oprot.writeFieldEnd()
7591 
    oprot.writeFieldStop()
7592 
    oprot.writeStructEnd()
7593 
 
7594 
  def validate(self):
7595 
    return
7596 
 
7597 
 
7598 
  def __repr__(self):
7599 
    L = ['%s=%r' % (key, value)
7600 
      for key, value in self.__dict__.iteritems()]
7601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7602 
 
7603 
  def __eq__(self, other):
7604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7605 
 
7606 
  def __ne__(self, other):
7607 
    return not (self == other)
7608 
 
7438 amit.gupta 7609 
class getItemsStatus_args:
7610 
  """
7611 
  Attributes:
7612 
   - itemIds
7613 
  """
7614 
 
7615 
  thrift_spec = (
7616 
    None, # 0
7617 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7618 
  )
7619 
 
7620 
  def __init__(self, itemIds=None,):
7621 
    self.itemIds = itemIds
7622 
 
7623 
  def read(self, iprot):
7624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7626 
      return
7627 
    iprot.readStructBegin()
7628 
    while True:
7629 
      (fname, ftype, fid) = iprot.readFieldBegin()
7630 
      if ftype == TType.STOP:
7631 
        break
7632 
      if fid == 1:
7633 
        if ftype == TType.LIST:
7634 
          self.itemIds = []
8590 kshitij.so 7635 
          (_etype33, _size30) = iprot.readListBegin()
7636 
          for _i34 in xrange(_size30):
7637 
            _elem35 = iprot.readI64();
7638 
            self.itemIds.append(_elem35)
7438 amit.gupta 7639 
          iprot.readListEnd()
7640 
        else:
7641 
          iprot.skip(ftype)
7642 
      else:
7643 
        iprot.skip(ftype)
7644 
      iprot.readFieldEnd()
7645 
    iprot.readStructEnd()
7646 
 
7647 
  def write(self, oprot):
7648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7650 
      return
7651 
    oprot.writeStructBegin('getItemsStatus_args')
7652 
    if self.itemIds is not None:
7653 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7654 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7655 
      for iter36 in self.itemIds:
7656 
        oprot.writeI64(iter36)
7438 amit.gupta 7657 
      oprot.writeListEnd()
7658 
      oprot.writeFieldEnd()
7659 
    oprot.writeFieldStop()
7660 
    oprot.writeStructEnd()
7661 
 
7662 
  def validate(self):
7663 
    return
7664 
 
7665 
 
7666 
  def __repr__(self):
7667 
    L = ['%s=%r' % (key, value)
7668 
      for key, value in self.__dict__.iteritems()]
7669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7670 
 
7671 
  def __eq__(self, other):
7672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7673 
 
7674 
  def __ne__(self, other):
7675 
    return not (self == other)
7676 
 
7677 
class getItemsStatus_result:
7678 
  """
7679 
  Attributes:
7680 
   - success
7681 
   - isex
7682 
  """
7683 
 
7684 
  thrift_spec = (
7685 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7686 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7687 
  )
7688 
 
7689 
  def __init__(self, success=None, isex=None,):
7690 
    self.success = success
7691 
    self.isex = isex
7692 
 
7693 
  def read(self, iprot):
7694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7696 
      return
7697 
    iprot.readStructBegin()
7698 
    while True:
7699 
      (fname, ftype, fid) = iprot.readFieldBegin()
7700 
      if ftype == TType.STOP:
7701 
        break
7702 
      if fid == 0:
7703 
        if ftype == TType.MAP:
7704 
          self.success = {}
8590 kshitij.so 7705 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7706 
          for _i41 in xrange(_size37):
7707 
            _key42 = iprot.readI64();
7708 
            _val43 = iprot.readBool();
7709 
            self.success[_key42] = _val43
7438 amit.gupta 7710 
          iprot.readMapEnd()
7711 
        else:
7712 
          iprot.skip(ftype)
7713 
      elif fid == 1:
7714 
        if ftype == TType.STRUCT:
7715 
          self.isex = CatalogServiceException()
7716 
          self.isex.read(iprot)
7717 
        else:
7718 
          iprot.skip(ftype)
7719 
      else:
7720 
        iprot.skip(ftype)
7721 
      iprot.readFieldEnd()
7722 
    iprot.readStructEnd()
7723 
 
7724 
  def write(self, oprot):
7725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7727 
      return
7728 
    oprot.writeStructBegin('getItemsStatus_result')
7729 
    if self.success is not None:
7730 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7731 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7732 
      for kiter44,viter45 in self.success.items():
7733 
        oprot.writeI64(kiter44)
7734 
        oprot.writeBool(viter45)
7438 amit.gupta 7735 
      oprot.writeMapEnd()
7736 
      oprot.writeFieldEnd()
7737 
    if self.isex is not None:
7738 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7739 
      self.isex.write(oprot)
7740 
      oprot.writeFieldEnd()
7741 
    oprot.writeFieldStop()
7742 
    oprot.writeStructEnd()
7743 
 
7744 
  def validate(self):
7745 
    return
7746 
 
7747 
 
7748 
  def __repr__(self):
7749 
    L = ['%s=%r' % (key, value)
7750 
      for key, value in self.__dict__.iteritems()]
7751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7752 
 
7753 
  def __eq__(self, other):
7754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7755 
 
7756 
  def __ne__(self, other):
7757 
    return not (self == other)
7758 
 
5944 mandeep.dh 7759 
class getItemStatusDescription_args:
7760 
  """
7761 
  Attributes:
7762 
   - itemId
7763 
  """
7764 
 
7765 
  thrift_spec = (
7766 
    None, # 0
7767 
    (1, TType.I64, 'itemId', None, None, ), # 1
7768 
  )
7769 
 
7770 
  def __init__(self, itemId=None,):
7771 
    self.itemId = itemId
7772 
 
7773 
  def read(self, iprot):
7774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7776 
      return
7777 
    iprot.readStructBegin()
7778 
    while True:
7779 
      (fname, ftype, fid) = iprot.readFieldBegin()
7780 
      if ftype == TType.STOP:
7781 
        break
7782 
      if fid == 1:
7783 
        if ftype == TType.I64:
7784 
          self.itemId = iprot.readI64();
7785 
        else:
7786 
          iprot.skip(ftype)
7787 
      else:
7788 
        iprot.skip(ftype)
7789 
      iprot.readFieldEnd()
7790 
    iprot.readStructEnd()
7791 
 
7792 
  def write(self, oprot):
7793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7795 
      return
7796 
    oprot.writeStructBegin('getItemStatusDescription_args')
7797 
    if self.itemId is not None:
7798 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7799 
      oprot.writeI64(self.itemId)
7800 
      oprot.writeFieldEnd()
7801 
    oprot.writeFieldStop()
7802 
    oprot.writeStructEnd()
7803 
 
7804 
  def validate(self):
7805 
    return
7806 
 
7807 
 
7808 
  def __repr__(self):
7809 
    L = ['%s=%r' % (key, value)
7810 
      for key, value in self.__dict__.iteritems()]
7811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7812 
 
7813 
  def __eq__(self, other):
7814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7815 
 
7816 
  def __ne__(self, other):
7817 
    return not (self == other)
7818 
 
7819 
class getItemStatusDescription_result:
7820 
  """
7821 
  Attributes:
7822 
   - success
7823 
   - isex
7824 
  """
7825 
 
7826 
  thrift_spec = (
7827 
    (0, TType.STRING, 'success', None, None, ), # 0
7828 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7829 
  )
7830 
 
7831 
  def __init__(self, success=None, isex=None,):
7832 
    self.success = success
7833 
    self.isex = isex
7834 
 
7835 
  def read(self, iprot):
7836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7838 
      return
7839 
    iprot.readStructBegin()
7840 
    while True:
7841 
      (fname, ftype, fid) = iprot.readFieldBegin()
7842 
      if ftype == TType.STOP:
7843 
        break
7844 
      if fid == 0:
7845 
        if ftype == TType.STRING:
7846 
          self.success = iprot.readString();
7847 
        else:
7848 
          iprot.skip(ftype)
7849 
      elif fid == 1:
7850 
        if ftype == TType.STRUCT:
7851 
          self.isex = CatalogServiceException()
7852 
          self.isex.read(iprot)
7853 
        else:
7854 
          iprot.skip(ftype)
7855 
      else:
7856 
        iprot.skip(ftype)
7857 
      iprot.readFieldEnd()
7858 
    iprot.readStructEnd()
7859 
 
7860 
  def write(self, oprot):
7861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7863 
      return
7864 
    oprot.writeStructBegin('getItemStatusDescription_result')
7865 
    if self.success is not None:
7866 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7867 
      oprot.writeString(self.success)
7868 
      oprot.writeFieldEnd()
7869 
    if self.isex is not None:
7870 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7871 
      self.isex.write(oprot)
7872 
      oprot.writeFieldEnd()
7873 
    oprot.writeFieldStop()
7874 
    oprot.writeStructEnd()
7875 
 
7876 
  def validate(self):
7877 
    return
7878 
 
7879 
 
7880 
  def __repr__(self):
7881 
    L = ['%s=%r' % (key, value)
7882 
      for key, value in self.__dict__.iteritems()]
7883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7884 
 
7885 
  def __eq__(self, other):
7886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7887 
 
7888 
  def __ne__(self, other):
7889 
    return not (self == other)
7890 
 
7891 
class startItemOn_args:
7892 
  """
7893 
  Attributes:
7894 
   - item_id
7895 
   - timestamp
7896 
  """
7897 
 
7898 
  thrift_spec = (
7899 
    None, # 0
7900 
    (1, TType.I64, 'item_id', None, None, ), # 1
7901 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7902 
  )
7903 
 
7904 
  def __init__(self, item_id=None, timestamp=None,):
7905 
    self.item_id = item_id
7906 
    self.timestamp = timestamp
7907 
 
7908 
  def read(self, iprot):
7909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7911 
      return
7912 
    iprot.readStructBegin()
7913 
    while True:
7914 
      (fname, ftype, fid) = iprot.readFieldBegin()
7915 
      if ftype == TType.STOP:
7916 
        break
7917 
      if fid == 1:
7918 
        if ftype == TType.I64:
7919 
          self.item_id = iprot.readI64();
7920 
        else:
7921 
          iprot.skip(ftype)
7922 
      elif fid == 2:
7923 
        if ftype == TType.I64:
7924 
          self.timestamp = iprot.readI64();
7925 
        else:
7926 
          iprot.skip(ftype)
7927 
      else:
7928 
        iprot.skip(ftype)
7929 
      iprot.readFieldEnd()
7930 
    iprot.readStructEnd()
7931 
 
7932 
  def write(self, oprot):
7933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7935 
      return
7936 
    oprot.writeStructBegin('startItemOn_args')
7937 
    if self.item_id is not None:
7938 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7939 
      oprot.writeI64(self.item_id)
7940 
      oprot.writeFieldEnd()
7941 
    if self.timestamp is not None:
7942 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7943 
      oprot.writeI64(self.timestamp)
7944 
      oprot.writeFieldEnd()
7945 
    oprot.writeFieldStop()
7946 
    oprot.writeStructEnd()
7947 
 
7948 
  def validate(self):
7949 
    return
7950 
 
7951 
 
7952 
  def __repr__(self):
7953 
    L = ['%s=%r' % (key, value)
7954 
      for key, value in self.__dict__.iteritems()]
7955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7956 
 
7957 
  def __eq__(self, other):
7958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7959 
 
7960 
  def __ne__(self, other):
7961 
    return not (self == other)
7962 
 
7963 
class startItemOn_result:
7964 
  """
7965 
  Attributes:
7966 
   - cex
7967 
  """
7968 
 
7969 
  thrift_spec = (
7970 
    None, # 0
7971 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7972 
  )
7973 
 
7974 
  def __init__(self, cex=None,):
7975 
    self.cex = cex
7976 
 
7977 
  def read(self, iprot):
7978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7980 
      return
7981 
    iprot.readStructBegin()
7982 
    while True:
7983 
      (fname, ftype, fid) = iprot.readFieldBegin()
7984 
      if ftype == TType.STOP:
7985 
        break
7986 
      if fid == 1:
7987 
        if ftype == TType.STRUCT:
7988 
          self.cex = CatalogServiceException()
7989 
          self.cex.read(iprot)
7990 
        else:
7991 
          iprot.skip(ftype)
7992 
      else:
7993 
        iprot.skip(ftype)
7994 
      iprot.readFieldEnd()
7995 
    iprot.readStructEnd()
7996 
 
7997 
  def write(self, oprot):
7998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8000 
      return
8001 
    oprot.writeStructBegin('startItemOn_result')
8002 
    if self.cex is not None:
8003 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8004 
      self.cex.write(oprot)
8005 
      oprot.writeFieldEnd()
8006 
    oprot.writeFieldStop()
8007 
    oprot.writeStructEnd()
8008 
 
8009 
  def validate(self):
8010 
    return
8011 
 
8012 
 
8013 
  def __repr__(self):
8014 
    L = ['%s=%r' % (key, value)
8015 
      for key, value in self.__dict__.iteritems()]
8016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8017 
 
8018 
  def __eq__(self, other):
8019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8020 
 
8021 
  def __ne__(self, other):
8022 
    return not (self == other)
8023 
 
8024 
class retireItemOn_args:
8025 
  """
8026 
  Attributes:
8027 
   - item_id
8028 
   - timestamp
8029 
  """
8030 
 
8031 
  thrift_spec = (
8032 
    None, # 0
8033 
    (1, TType.I64, 'item_id', None, None, ), # 1
8034 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8035 
  )
8036 
 
8037 
  def __init__(self, item_id=None, timestamp=None,):
8038 
    self.item_id = item_id
8039 
    self.timestamp = timestamp
8040 
 
8041 
  def read(self, iprot):
8042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8044 
      return
8045 
    iprot.readStructBegin()
8046 
    while True:
8047 
      (fname, ftype, fid) = iprot.readFieldBegin()
8048 
      if ftype == TType.STOP:
8049 
        break
8050 
      if fid == 1:
8051 
        if ftype == TType.I64:
8052 
          self.item_id = iprot.readI64();
8053 
        else:
8054 
          iprot.skip(ftype)
8055 
      elif fid == 2:
8056 
        if ftype == TType.I64:
8057 
          self.timestamp = iprot.readI64();
8058 
        else:
8059 
          iprot.skip(ftype)
8060 
      else:
8061 
        iprot.skip(ftype)
8062 
      iprot.readFieldEnd()
8063 
    iprot.readStructEnd()
8064 
 
8065 
  def write(self, oprot):
8066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8068 
      return
8069 
    oprot.writeStructBegin('retireItemOn_args')
8070 
    if self.item_id is not None:
8071 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8072 
      oprot.writeI64(self.item_id)
8073 
      oprot.writeFieldEnd()
8074 
    if self.timestamp is not None:
8075 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8076 
      oprot.writeI64(self.timestamp)
8077 
      oprot.writeFieldEnd()
8078 
    oprot.writeFieldStop()
8079 
    oprot.writeStructEnd()
8080 
 
8081 
  def validate(self):
8082 
    return
8083 
 
8084 
 
8085 
  def __repr__(self):
8086 
    L = ['%s=%r' % (key, value)
8087 
      for key, value in self.__dict__.iteritems()]
8088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8089 
 
8090 
  def __eq__(self, other):
8091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8092 
 
8093 
  def __ne__(self, other):
8094 
    return not (self == other)
8095 
 
8096 
class retireItemOn_result:
8097 
  """
8098 
  Attributes:
8099 
   - cex
8100 
  """
8101 
 
8102 
  thrift_spec = (
8103 
    None, # 0
8104 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8105 
  )
8106 
 
8107 
  def __init__(self, cex=None,):
8108 
    self.cex = cex
8109 
 
8110 
  def read(self, iprot):
8111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8113 
      return
8114 
    iprot.readStructBegin()
8115 
    while True:
8116 
      (fname, ftype, fid) = iprot.readFieldBegin()
8117 
      if ftype == TType.STOP:
8118 
        break
8119 
      if fid == 1:
8120 
        if ftype == TType.STRUCT:
8121 
          self.cex = CatalogServiceException()
8122 
          self.cex.read(iprot)
8123 
        else:
8124 
          iprot.skip(ftype)
8125 
      else:
8126 
        iprot.skip(ftype)
8127 
      iprot.readFieldEnd()
8128 
    iprot.readStructEnd()
8129 
 
8130 
  def write(self, oprot):
8131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8133 
      return
8134 
    oprot.writeStructBegin('retireItemOn_result')
8135 
    if self.cex is not None:
8136 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8137 
      self.cex.write(oprot)
8138 
      oprot.writeFieldEnd()
8139 
    oprot.writeFieldStop()
8140 
    oprot.writeStructEnd()
8141 
 
8142 
  def validate(self):
8143 
    return
8144 
 
8145 
 
8146 
  def __repr__(self):
8147 
    L = ['%s=%r' % (key, value)
8148 
      for key, value in self.__dict__.iteritems()]
8149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8150 
 
8151 
  def __eq__(self, other):
8152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8153 
 
8154 
  def __ne__(self, other):
8155 
    return not (self == other)
8156 
 
8157 
class changeItemStatus_args:
8158 
  """
8159 
  Attributes:
8160 
   - item_id
8161 
   - timestamp
8162 
   - newstatus
8163 
  """
8164 
 
8165 
  thrift_spec = (
8166 
    None, # 0
8167 
    (1, TType.I64, 'item_id', None, None, ), # 1
8168 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8169 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8170 
  )
8171 
 
8172 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8173 
    self.item_id = item_id
8174 
    self.timestamp = timestamp
8175 
    self.newstatus = newstatus
8176 
 
8177 
  def read(self, iprot):
8178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8180 
      return
8181 
    iprot.readStructBegin()
8182 
    while True:
8183 
      (fname, ftype, fid) = iprot.readFieldBegin()
8184 
      if ftype == TType.STOP:
8185 
        break
8186 
      if fid == 1:
8187 
        if ftype == TType.I64:
8188 
          self.item_id = iprot.readI64();
8189 
        else:
8190 
          iprot.skip(ftype)
8191 
      elif fid == 2:
8192 
        if ftype == TType.I64:
8193 
          self.timestamp = iprot.readI64();
8194 
        else:
8195 
          iprot.skip(ftype)
8196 
      elif fid == 3:
8197 
        if ftype == TType.I32:
8198 
          self.newstatus = iprot.readI32();
8199 
        else:
8200 
          iprot.skip(ftype)
8201 
      else:
8202 
        iprot.skip(ftype)
8203 
      iprot.readFieldEnd()
8204 
    iprot.readStructEnd()
8205 
 
8206 
  def write(self, oprot):
8207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8209 
      return
8210 
    oprot.writeStructBegin('changeItemStatus_args')
8211 
    if self.item_id is not None:
8212 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8213 
      oprot.writeI64(self.item_id)
8214 
      oprot.writeFieldEnd()
8215 
    if self.timestamp is not None:
8216 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8217 
      oprot.writeI64(self.timestamp)
8218 
      oprot.writeFieldEnd()
8219 
    if self.newstatus is not None:
8220 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8221 
      oprot.writeI32(self.newstatus)
8222 
      oprot.writeFieldEnd()
8223 
    oprot.writeFieldStop()
8224 
    oprot.writeStructEnd()
8225 
 
8226 
  def validate(self):
8227 
    return
8228 
 
8229 
 
8230 
  def __repr__(self):
8231 
    L = ['%s=%r' % (key, value)
8232 
      for key, value in self.__dict__.iteritems()]
8233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8234 
 
8235 
  def __eq__(self, other):
8236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8237 
 
8238 
  def __ne__(self, other):
8239 
    return not (self == other)
8240 
 
8241 
class changeItemStatus_result:
8242 
  """
8243 
  Attributes:
8244 
   - cex
8245 
  """
8246 
 
8247 
  thrift_spec = (
8248 
    None, # 0
8249 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8250 
  )
8251 
 
8252 
  def __init__(self, cex=None,):
8253 
    self.cex = cex
8254 
 
8255 
  def read(self, iprot):
8256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8258 
      return
8259 
    iprot.readStructBegin()
8260 
    while True:
8261 
      (fname, ftype, fid) = iprot.readFieldBegin()
8262 
      if ftype == TType.STOP:
8263 
        break
8264 
      if fid == 1:
8265 
        if ftype == TType.STRUCT:
8266 
          self.cex = CatalogServiceException()
8267 
          self.cex.read(iprot)
8268 
        else:
8269 
          iprot.skip(ftype)
8270 
      else:
8271 
        iprot.skip(ftype)
8272 
      iprot.readFieldEnd()
8273 
    iprot.readStructEnd()
8274 
 
8275 
  def write(self, oprot):
8276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8278 
      return
8279 
    oprot.writeStructBegin('changeItemStatus_result')
8280 
    if self.cex is not None:
8281 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8282 
      self.cex.write(oprot)
8283 
      oprot.writeFieldEnd()
8284 
    oprot.writeFieldStop()
8285 
    oprot.writeStructEnd()
8286 
 
8287 
  def validate(self):
8288 
    return
8289 
 
8290 
 
8291 
  def __repr__(self):
8292 
    L = ['%s=%r' % (key, value)
8293 
      for key, value in self.__dict__.iteritems()]
8294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8295 
 
8296 
  def __eq__(self, other):
8297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8298 
 
8299 
  def __ne__(self, other):
8300 
    return not (self == other)
8301 
 
8302 
class getItem_args:
8303 
  """
8304 
  Attributes:
8305 
   - item_id
8306 
  """
8307 
 
8308 
  thrift_spec = (
8309 
    None, # 0
8310 
    (1, TType.I64, 'item_id', None, None, ), # 1
8311 
  )
8312 
 
8313 
  def __init__(self, item_id=None,):
8314 
    self.item_id = item_id
8315 
 
8316 
  def read(self, iprot):
8317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8319 
      return
8320 
    iprot.readStructBegin()
8321 
    while True:
8322 
      (fname, ftype, fid) = iprot.readFieldBegin()
8323 
      if ftype == TType.STOP:
8324 
        break
8325 
      if fid == 1:
8326 
        if ftype == TType.I64:
8327 
          self.item_id = iprot.readI64();
8328 
        else:
8329 
          iprot.skip(ftype)
8330 
      else:
8331 
        iprot.skip(ftype)
8332 
      iprot.readFieldEnd()
8333 
    iprot.readStructEnd()
8334 
 
8335 
  def write(self, oprot):
8336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8338 
      return
8339 
    oprot.writeStructBegin('getItem_args')
8340 
    if self.item_id is not None:
8341 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8342 
      oprot.writeI64(self.item_id)
8343 
      oprot.writeFieldEnd()
8344 
    oprot.writeFieldStop()
8345 
    oprot.writeStructEnd()
8346 
 
8347 
  def validate(self):
8348 
    return
8349 
 
8350 
 
8351 
  def __repr__(self):
8352 
    L = ['%s=%r' % (key, value)
8353 
      for key, value in self.__dict__.iteritems()]
8354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8355 
 
8356 
  def __eq__(self, other):
8357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8358 
 
8359 
  def __ne__(self, other):
8360 
    return not (self == other)
8361 
 
8362 
class getItem_result:
8363 
  """
8364 
  Attributes:
8365 
   - success
8366 
   - cex
8367 
  """
8368 
 
8369 
  thrift_spec = (
8370 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
8371 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8372 
  )
8373 
 
8374 
  def __init__(self, success=None, cex=None,):
8375 
    self.success = success
8376 
    self.cex = cex
8377 
 
8378 
  def read(self, iprot):
8379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8381 
      return
8382 
    iprot.readStructBegin()
8383 
    while True:
8384 
      (fname, ftype, fid) = iprot.readFieldBegin()
8385 
      if ftype == TType.STOP:
8386 
        break
8387 
      if fid == 0:
8388 
        if ftype == TType.STRUCT:
8389 
          self.success = Item()
8390 
          self.success.read(iprot)
8391 
        else:
8392 
          iprot.skip(ftype)
8393 
      elif fid == 1:
8394 
        if ftype == TType.STRUCT:
8395 
          self.cex = CatalogServiceException()
8396 
          self.cex.read(iprot)
8397 
        else:
8398 
          iprot.skip(ftype)
8399 
      else:
8400 
        iprot.skip(ftype)
8401 
      iprot.readFieldEnd()
8402 
    iprot.readStructEnd()
8403 
 
8404 
  def write(self, oprot):
8405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8407 
      return
8408 
    oprot.writeStructBegin('getItem_result')
8409 
    if self.success is not None:
8410 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8411 
      self.success.write(oprot)
8412 
      oprot.writeFieldEnd()
8413 
    if self.cex is not None:
8414 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8415 
      self.cex.write(oprot)
8416 
      oprot.writeFieldEnd()
8417 
    oprot.writeFieldStop()
8418 
    oprot.writeStructEnd()
8419 
 
8420 
  def validate(self):
8421 
    return
8422 
 
8423 
 
8424 
  def __repr__(self):
8425 
    L = ['%s=%r' % (key, value)
8426 
      for key, value in self.__dict__.iteritems()]
8427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8428 
 
8429 
  def __eq__(self, other):
8430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8431 
 
8432 
  def __ne__(self, other):
8433 
    return not (self == other)
8434 
 
8435 
class getItemsByCatalogId_args:
8436 
  """
8437 
  Attributes:
8438 
   - catalog_item_id
8439 
  """
8440 
 
8441 
  thrift_spec = (
8442 
    None, # 0
8443 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8444 
  )
8445 
 
8446 
  def __init__(self, catalog_item_id=None,):
8447 
    self.catalog_item_id = catalog_item_id
8448 
 
8449 
  def read(self, iprot):
8450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8452 
      return
8453 
    iprot.readStructBegin()
8454 
    while True:
8455 
      (fname, ftype, fid) = iprot.readFieldBegin()
8456 
      if ftype == TType.STOP:
8457 
        break
8458 
      if fid == 1:
8459 
        if ftype == TType.I64:
8460 
          self.catalog_item_id = iprot.readI64();
8461 
        else:
8462 
          iprot.skip(ftype)
8463 
      else:
8464 
        iprot.skip(ftype)
8465 
      iprot.readFieldEnd()
8466 
    iprot.readStructEnd()
8467 
 
8468 
  def write(self, oprot):
8469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8471 
      return
8472 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8473 
    if self.catalog_item_id is not None:
8474 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8475 
      oprot.writeI64(self.catalog_item_id)
8476 
      oprot.writeFieldEnd()
8477 
    oprot.writeFieldStop()
8478 
    oprot.writeStructEnd()
8479 
 
8480 
  def validate(self):
8481 
    return
8482 
 
8483 
 
8484 
  def __repr__(self):
8485 
    L = ['%s=%r' % (key, value)
8486 
      for key, value in self.__dict__.iteritems()]
8487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8488 
 
8489 
  def __eq__(self, other):
8490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8491 
 
8492 
  def __ne__(self, other):
8493 
    return not (self == other)
8494 
 
8495 
class getItemsByCatalogId_result:
8496 
  """
8497 
  Attributes:
8498 
   - success
8499 
   - cex
8500 
  """
8501 
 
8502 
  thrift_spec = (
8503 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8504 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8505 
  )
8506 
 
8507 
  def __init__(self, success=None, cex=None,):
8508 
    self.success = success
8509 
    self.cex = cex
8510 
 
8511 
  def read(self, iprot):
8512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8514 
      return
8515 
    iprot.readStructBegin()
8516 
    while True:
8517 
      (fname, ftype, fid) = iprot.readFieldBegin()
8518 
      if ftype == TType.STOP:
8519 
        break
8520 
      if fid == 0:
8521 
        if ftype == TType.LIST:
8522 
          self.success = []
8590 kshitij.so 8523 
          (_etype49, _size46) = iprot.readListBegin()
8524 
          for _i50 in xrange(_size46):
8525 
            _elem51 = Item()
8526 
            _elem51.read(iprot)
8527 
            self.success.append(_elem51)
5944 mandeep.dh 8528 
          iprot.readListEnd()
8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      elif fid == 1:
8532 
        if ftype == TType.STRUCT:
8533 
          self.cex = CatalogServiceException()
8534 
          self.cex.read(iprot)
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      else:
8538 
        iprot.skip(ftype)
8539 
      iprot.readFieldEnd()
8540 
    iprot.readStructEnd()
8541 
 
8542 
  def write(self, oprot):
8543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8545 
      return
8546 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8547 
    if self.success is not None:
8548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8549 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8550 
      for iter52 in self.success:
8551 
        iter52.write(oprot)
5944 mandeep.dh 8552 
      oprot.writeListEnd()
8553 
      oprot.writeFieldEnd()
8554 
    if self.cex is not None:
8555 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8556 
      self.cex.write(oprot)
8557 
      oprot.writeFieldEnd()
8558 
    oprot.writeFieldStop()
8559 
    oprot.writeStructEnd()
8560 
 
8561 
  def validate(self):
8562 
    return
8563 
 
8564 
 
8565 
  def __repr__(self):
8566 
    L = ['%s=%r' % (key, value)
8567 
      for key, value in self.__dict__.iteritems()]
8568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8569 
 
8570 
  def __eq__(self, other):
8571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8572 
 
8573 
  def __ne__(self, other):
8574 
    return not (self == other)
8575 
 
8576 
class getValidItemsByCatalogId_args:
8577 
  """
8578 
  Attributes:
8579 
   - catalog_item_id
8580 
  """
8581 
 
8582 
  thrift_spec = (
8583 
    None, # 0
8584 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8585 
  )
8586 
 
8587 
  def __init__(self, catalog_item_id=None,):
8588 
    self.catalog_item_id = catalog_item_id
8589 
 
8590 
  def read(self, iprot):
8591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8593 
      return
8594 
    iprot.readStructBegin()
8595 
    while True:
8596 
      (fname, ftype, fid) = iprot.readFieldBegin()
8597 
      if ftype == TType.STOP:
8598 
        break
8599 
      if fid == 1:
8600 
        if ftype == TType.I64:
8601 
          self.catalog_item_id = iprot.readI64();
8602 
        else:
8603 
          iprot.skip(ftype)
8604 
      else:
8605 
        iprot.skip(ftype)
8606 
      iprot.readFieldEnd()
8607 
    iprot.readStructEnd()
8608 
 
8609 
  def write(self, oprot):
8610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8612 
      return
8613 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8614 
    if self.catalog_item_id is not None:
8615 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8616 
      oprot.writeI64(self.catalog_item_id)
8617 
      oprot.writeFieldEnd()
8618 
    oprot.writeFieldStop()
8619 
    oprot.writeStructEnd()
8620 
 
8621 
  def validate(self):
8622 
    return
8623 
 
8624 
 
8625 
  def __repr__(self):
8626 
    L = ['%s=%r' % (key, value)
8627 
      for key, value in self.__dict__.iteritems()]
8628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8629 
 
8630 
  def __eq__(self, other):
8631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8632 
 
8633 
  def __ne__(self, other):
8634 
    return not (self == other)
8635 
 
8636 
class getValidItemsByCatalogId_result:
8637 
  """
8638 
  Attributes:
8639 
   - success
8640 
   - cex
8641 
  """
8642 
 
8643 
  thrift_spec = (
8644 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8645 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8646 
  )
8647 
 
8648 
  def __init__(self, success=None, cex=None,):
8649 
    self.success = success
8650 
    self.cex = cex
8651 
 
8652 
  def read(self, iprot):
8653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8655 
      return
8656 
    iprot.readStructBegin()
8657 
    while True:
8658 
      (fname, ftype, fid) = iprot.readFieldBegin()
8659 
      if ftype == TType.STOP:
8660 
        break
8661 
      if fid == 0:
8662 
        if ftype == TType.LIST:
8663 
          self.success = []
8590 kshitij.so 8664 
          (_etype56, _size53) = iprot.readListBegin()
8665 
          for _i57 in xrange(_size53):
8666 
            _elem58 = Item()
8667 
            _elem58.read(iprot)
8668 
            self.success.append(_elem58)
5944 mandeep.dh 8669 
          iprot.readListEnd()
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      elif fid == 1:
8673 
        if ftype == TType.STRUCT:
8674 
          self.cex = CatalogServiceException()
8675 
          self.cex.read(iprot)
8676 
        else:
8677 
          iprot.skip(ftype)
8678 
      else:
8679 
        iprot.skip(ftype)
8680 
      iprot.readFieldEnd()
8681 
    iprot.readStructEnd()
8682 
 
8683 
  def write(self, oprot):
8684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8686 
      return
8687 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8688 
    if self.success is not None:
8689 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8690 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8691 
      for iter59 in self.success:
8692 
        iter59.write(oprot)
5944 mandeep.dh 8693 
      oprot.writeListEnd()
8694 
      oprot.writeFieldEnd()
8695 
    if self.cex is not None:
8696 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8697 
      self.cex.write(oprot)
8698 
      oprot.writeFieldEnd()
8699 
    oprot.writeFieldStop()
8700 
    oprot.writeStructEnd()
8701 
 
8702 
  def validate(self):
8703 
    return
8704 
 
8705 
 
8706 
  def __repr__(self):
8707 
    L = ['%s=%r' % (key, value)
8708 
      for key, value in self.__dict__.iteritems()]
8709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8710 
 
8711 
  def __eq__(self, other):
8712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8713 
 
8714 
  def __ne__(self, other):
8715 
    return not (self == other)
8716 
 
8717 
class getAllItems_args:
8718 
  """
8719 
  Attributes:
8720 
   - isActive
8721 
  """
8722 
 
8723 
  thrift_spec = (
8724 
    None, # 0
8725 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8726 
  )
8727 
 
8728 
  def __init__(self, isActive=None,):
8729 
    self.isActive = isActive
8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      if fid == 1:
8741 
        if ftype == TType.BOOL:
8742 
          self.isActive = iprot.readBool();
8743 
        else:
8744 
          iprot.skip(ftype)
8745 
      else:
8746 
        iprot.skip(ftype)
8747 
      iprot.readFieldEnd()
8748 
    iprot.readStructEnd()
8749 
 
8750 
  def write(self, oprot):
8751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8753 
      return
8754 
    oprot.writeStructBegin('getAllItems_args')
8755 
    if self.isActive is not None:
8756 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8757 
      oprot.writeBool(self.isActive)
8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
8777 
class getAllItems_result:
8778 
  """
8779 
  Attributes:
8780 
   - success
8781 
   - cex
8782 
  """
8783 
 
8784 
  thrift_spec = (
8785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8786 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8787 
  )
8788 
 
8789 
  def __init__(self, success=None, cex=None,):
8790 
    self.success = success
8791 
    self.cex = cex
8792 
 
8793 
  def read(self, iprot):
8794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8796 
      return
8797 
    iprot.readStructBegin()
8798 
    while True:
8799 
      (fname, ftype, fid) = iprot.readFieldBegin()
8800 
      if ftype == TType.STOP:
8801 
        break
8802 
      if fid == 0:
8803 
        if ftype == TType.LIST:
8804 
          self.success = []
8590 kshitij.so 8805 
          (_etype63, _size60) = iprot.readListBegin()
8806 
          for _i64 in xrange(_size60):
8807 
            _elem65 = Item()
8808 
            _elem65.read(iprot)
8809 
            self.success.append(_elem65)
5944 mandeep.dh 8810 
          iprot.readListEnd()
8811 
        else:
8812 
          iprot.skip(ftype)
8813 
      elif fid == 1:
8814 
        if ftype == TType.STRUCT:
8815 
          self.cex = CatalogServiceException()
8816 
          self.cex.read(iprot)
8817 
        else:
8818 
          iprot.skip(ftype)
8819 
      else:
8820 
        iprot.skip(ftype)
8821 
      iprot.readFieldEnd()
8822 
    iprot.readStructEnd()
8823 
 
8824 
  def write(self, oprot):
8825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8827 
      return
8828 
    oprot.writeStructBegin('getAllItems_result')
8829 
    if self.success is not None:
8830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8832 
      for iter66 in self.success:
8833 
        iter66.write(oprot)
5944 mandeep.dh 8834 
      oprot.writeListEnd()
8835 
      oprot.writeFieldEnd()
8836 
    if self.cex is not None:
8837 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8838 
      self.cex.write(oprot)
8839 
      oprot.writeFieldEnd()
8840 
    oprot.writeFieldStop()
8841 
    oprot.writeStructEnd()
8842 
 
8843 
  def validate(self):
8844 
    return
8845 
 
8846 
 
8847 
  def __repr__(self):
8848 
    L = ['%s=%r' % (key, value)
8849 
      for key, value in self.__dict__.iteritems()]
8850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8851 
 
8852 
  def __eq__(self, other):
8853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8854 
 
8855 
  def __ne__(self, other):
8856 
    return not (self == other)
8857 
 
8858 
class getAllItemsByStatus_args:
8859 
  """
8860 
  Attributes:
8861 
   - itemStatus
8862 
  """
8863 
 
8864 
  thrift_spec = (
8865 
    None, # 0
8866 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8867 
  )
8868 
 
8869 
  def __init__(self, itemStatus=None,):
8870 
    self.itemStatus = itemStatus
8871 
 
8872 
  def read(self, iprot):
8873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8875 
      return
8876 
    iprot.readStructBegin()
8877 
    while True:
8878 
      (fname, ftype, fid) = iprot.readFieldBegin()
8879 
      if ftype == TType.STOP:
8880 
        break
8881 
      if fid == 1:
8882 
        if ftype == TType.I32:
8883 
          self.itemStatus = iprot.readI32();
8884 
        else:
8885 
          iprot.skip(ftype)
8886 
      else:
8887 
        iprot.skip(ftype)
8888 
      iprot.readFieldEnd()
8889 
    iprot.readStructEnd()
8890 
 
8891 
  def write(self, oprot):
8892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8894 
      return
8895 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8896 
    if self.itemStatus is not None:
8897 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8898 
      oprot.writeI32(self.itemStatus)
8899 
      oprot.writeFieldEnd()
8900 
    oprot.writeFieldStop()
8901 
    oprot.writeStructEnd()
8902 
 
8903 
  def validate(self):
8904 
    return
8905 
 
8906 
 
8907 
  def __repr__(self):
8908 
    L = ['%s=%r' % (key, value)
8909 
      for key, value in self.__dict__.iteritems()]
8910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8911 
 
8912 
  def __eq__(self, other):
8913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8914 
 
8915 
  def __ne__(self, other):
8916 
    return not (self == other)
8917 
 
8918 
class getAllItemsByStatus_result:
8919 
  """
8920 
  Attributes:
8921 
   - success
8922 
   - cex
8923 
  """
8924 
 
8925 
  thrift_spec = (
8926 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8927 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8928 
  )
8929 
 
8930 
  def __init__(self, success=None, cex=None,):
8931 
    self.success = success
8932 
    self.cex = cex
8933 
 
8934 
  def read(self, iprot):
8935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8937 
      return
8938 
    iprot.readStructBegin()
8939 
    while True:
8940 
      (fname, ftype, fid) = iprot.readFieldBegin()
8941 
      if ftype == TType.STOP:
8942 
        break
8943 
      if fid == 0:
8944 
        if ftype == TType.LIST:
8945 
          self.success = []
8590 kshitij.so 8946 
          (_etype70, _size67) = iprot.readListBegin()
8947 
          for _i71 in xrange(_size67):
8948 
            _elem72 = Item()
8949 
            _elem72.read(iprot)
8950 
            self.success.append(_elem72)
5944 mandeep.dh 8951 
          iprot.readListEnd()
8952 
        else:
8953 
          iprot.skip(ftype)
8954 
      elif fid == 1:
8955 
        if ftype == TType.STRUCT:
8956 
          self.cex = CatalogServiceException()
8957 
          self.cex.read(iprot)
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8970 
    if self.success is not None:
8971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8973 
      for iter73 in self.success:
8974 
        iter73.write(oprot)
5944 mandeep.dh 8975 
      oprot.writeListEnd()
8976 
      oprot.writeFieldEnd()
8977 
    if self.cex is not None:
8978 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8979 
      self.cex.write(oprot)
8980 
      oprot.writeFieldEnd()
8981 
    oprot.writeFieldStop()
8982 
    oprot.writeStructEnd()
8983 
 
8984 
  def validate(self):
8985 
    return
8986 
 
8987 
 
8988 
  def __repr__(self):
8989 
    L = ['%s=%r' % (key, value)
8990 
      for key, value in self.__dict__.iteritems()]
8991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8992 
 
8993 
  def __eq__(self, other):
8994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8995 
 
8996 
  def __ne__(self, other):
8997 
    return not (self == other)
8998 
 
8999 
class markItemAsContentComplete_args:
9000 
  """
9001 
  Attributes:
9002 
   - entityId
9003 
   - category
9004 
   - brand
9005 
   - modelName
9006 
   - modelNumber
9253 rajveer 9007 
   - isAndroid
5944 mandeep.dh 9008 
  """
9009 
 
9010 
  thrift_spec = (
9011 
    None, # 0
9012 
    (1, TType.I64, 'entityId', None, None, ), # 1
9013 
    (2, TType.I64, 'category', None, None, ), # 2
9014 
    (3, TType.STRING, 'brand', None, None, ), # 3
9015 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9016 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9017 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9018 
  )
9019 
 
9253 rajveer 9020 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9021 
    self.entityId = entityId
9022 
    self.category = category
9023 
    self.brand = brand
9024 
    self.modelName = modelName
9025 
    self.modelNumber = modelNumber
9253 rajveer 9026 
    self.isAndroid = isAndroid
5944 mandeep.dh 9027 
 
9028 
  def read(self, iprot):
9029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9031 
      return
9032 
    iprot.readStructBegin()
9033 
    while True:
9034 
      (fname, ftype, fid) = iprot.readFieldBegin()
9035 
      if ftype == TType.STOP:
9036 
        break
9037 
      if fid == 1:
9038 
        if ftype == TType.I64:
9039 
          self.entityId = iprot.readI64();
9040 
        else:
9041 
          iprot.skip(ftype)
9042 
      elif fid == 2:
9043 
        if ftype == TType.I64:
9044 
          self.category = iprot.readI64();
9045 
        else:
9046 
          iprot.skip(ftype)
9047 
      elif fid == 3:
9048 
        if ftype == TType.STRING:
9049 
          self.brand = iprot.readString();
9050 
        else:
9051 
          iprot.skip(ftype)
9052 
      elif fid == 4:
9053 
        if ftype == TType.STRING:
9054 
          self.modelName = iprot.readString();
9055 
        else:
9056 
          iprot.skip(ftype)
9057 
      elif fid == 5:
9058 
        if ftype == TType.STRING:
9059 
          self.modelNumber = iprot.readString();
9060 
        else:
9061 
          iprot.skip(ftype)
9253 rajveer 9062 
      elif fid == 6:
9063 
        if ftype == TType.BOOL:
9064 
          self.isAndroid = iprot.readBool();
9065 
        else:
9066 
          iprot.skip(ftype)
5944 mandeep.dh 9067 
      else:
9068 
        iprot.skip(ftype)
9069 
      iprot.readFieldEnd()
9070 
    iprot.readStructEnd()
9071 
 
9072 
  def write(self, oprot):
9073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9075 
      return
9076 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9077 
    if self.entityId is not None:
9078 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9079 
      oprot.writeI64(self.entityId)
9080 
      oprot.writeFieldEnd()
9081 
    if self.category is not None:
9082 
      oprot.writeFieldBegin('category', TType.I64, 2)
9083 
      oprot.writeI64(self.category)
9084 
      oprot.writeFieldEnd()
9085 
    if self.brand is not None:
9086 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9087 
      oprot.writeString(self.brand)
9088 
      oprot.writeFieldEnd()
9089 
    if self.modelName is not None:
9090 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9091 
      oprot.writeString(self.modelName)
9092 
      oprot.writeFieldEnd()
9093 
    if self.modelNumber is not None:
9094 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9095 
      oprot.writeString(self.modelNumber)
9096 
      oprot.writeFieldEnd()
9253 rajveer 9097 
    if self.isAndroid is not None:
9098 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9099 
      oprot.writeBool(self.isAndroid)
9100 
      oprot.writeFieldEnd()
5944 mandeep.dh 9101 
    oprot.writeFieldStop()
9102 
    oprot.writeStructEnd()
9103 
 
9104 
  def validate(self):
9105 
    return
9106 
 
9107 
 
9108 
  def __repr__(self):
9109 
    L = ['%s=%r' % (key, value)
9110 
      for key, value in self.__dict__.iteritems()]
9111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9112 
 
9113 
  def __eq__(self, other):
9114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9115 
 
9116 
  def __ne__(self, other):
9117 
    return not (self == other)
9118 
 
9119 
class markItemAsContentComplete_result:
9120 
  """
9121 
  Attributes:
9122 
   - success
9123 
   - cex
9124 
  """
9125 
 
9126 
  thrift_spec = (
9127 
    (0, TType.BOOL, 'success', None, None, ), # 0
9128 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9129 
  )
9130 
 
9131 
  def __init__(self, success=None, cex=None,):
9132 
    self.success = success
9133 
    self.cex = cex
9134 
 
9135 
  def read(self, iprot):
9136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9138 
      return
9139 
    iprot.readStructBegin()
9140 
    while True:
9141 
      (fname, ftype, fid) = iprot.readFieldBegin()
9142 
      if ftype == TType.STOP:
9143 
        break
9144 
      if fid == 0:
9145 
        if ftype == TType.BOOL:
9146 
          self.success = iprot.readBool();
9147 
        else:
9148 
          iprot.skip(ftype)
9149 
      elif fid == 1:
9150 
        if ftype == TType.STRUCT:
9151 
          self.cex = CatalogServiceException()
9152 
          self.cex.read(iprot)
9153 
        else:
9154 
          iprot.skip(ftype)
9155 
      else:
9156 
        iprot.skip(ftype)
9157 
      iprot.readFieldEnd()
9158 
    iprot.readStructEnd()
9159 
 
9160 
  def write(self, oprot):
9161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9163 
      return
9164 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9165 
    if self.success is not None:
9166 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9167 
      oprot.writeBool(self.success)
9168 
      oprot.writeFieldEnd()
9169 
    if self.cex is not None:
9170 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9171 
      self.cex.write(oprot)
9172 
      oprot.writeFieldEnd()
9173 
    oprot.writeFieldStop()
9174 
    oprot.writeStructEnd()
9175 
 
9176 
  def validate(self):
9177 
    return
9178 
 
9179 
 
9180 
  def __repr__(self):
9181 
    L = ['%s=%r' % (key, value)
9182 
      for key, value in self.__dict__.iteritems()]
9183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9184 
 
9185 
  def __eq__(self, other):
9186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9187 
 
9188 
  def __ne__(self, other):
9189 
    return not (self == other)
9190 
 
9191 
class getAllItemsInRange_args:
9192 
  """
9193 
  Attributes:
9194 
   - offset
9195 
   - limit
9196 
  """
9197 
 
9198 
  thrift_spec = (
9199 
    None, # 0
9200 
    (1, TType.I64, 'offset', None, None, ), # 1
9201 
    (2, TType.I64, 'limit', None, None, ), # 2
9202 
  )
9203 
 
9204 
  def __init__(self, offset=None, limit=None,):
9205 
    self.offset = offset
9206 
    self.limit = limit
9207 
 
9208 
  def read(self, iprot):
9209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9211 
      return
9212 
    iprot.readStructBegin()
9213 
    while True:
9214 
      (fname, ftype, fid) = iprot.readFieldBegin()
9215 
      if ftype == TType.STOP:
9216 
        break
9217 
      if fid == 1:
9218 
        if ftype == TType.I64:
9219 
          self.offset = iprot.readI64();
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      elif fid == 2:
9223 
        if ftype == TType.I64:
9224 
          self.limit = iprot.readI64();
9225 
        else:
9226 
          iprot.skip(ftype)
9227 
      else:
9228 
        iprot.skip(ftype)
9229 
      iprot.readFieldEnd()
9230 
    iprot.readStructEnd()
9231 
 
9232 
  def write(self, oprot):
9233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9235 
      return
9236 
    oprot.writeStructBegin('getAllItemsInRange_args')
9237 
    if self.offset is not None:
9238 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9239 
      oprot.writeI64(self.offset)
9240 
      oprot.writeFieldEnd()
9241 
    if self.limit is not None:
9242 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9243 
      oprot.writeI64(self.limit)
9244 
      oprot.writeFieldEnd()
9245 
    oprot.writeFieldStop()
9246 
    oprot.writeStructEnd()
9247 
 
9248 
  def validate(self):
9249 
    return
9250 
 
9251 
 
9252 
  def __repr__(self):
9253 
    L = ['%s=%r' % (key, value)
9254 
      for key, value in self.__dict__.iteritems()]
9255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9256 
 
9257 
  def __eq__(self, other):
9258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9259 
 
9260 
  def __ne__(self, other):
9261 
    return not (self == other)
9262 
 
9263 
class getAllItemsInRange_result:
9264 
  """
9265 
  Attributes:
9266 
   - success
9267 
   - cex
9268 
  """
9269 
 
9270 
  thrift_spec = (
9271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9272 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9273 
  )
9274 
 
9275 
  def __init__(self, success=None, cex=None,):
9276 
    self.success = success
9277 
    self.cex = cex
9278 
 
9279 
  def read(self, iprot):
9280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9282 
      return
9283 
    iprot.readStructBegin()
9284 
    while True:
9285 
      (fname, ftype, fid) = iprot.readFieldBegin()
9286 
      if ftype == TType.STOP:
9287 
        break
9288 
      if fid == 0:
9289 
        if ftype == TType.LIST:
9290 
          self.success = []
8590 kshitij.so 9291 
          (_etype77, _size74) = iprot.readListBegin()
9292 
          for _i78 in xrange(_size74):
9293 
            _elem79 = Item()
9294 
            _elem79.read(iprot)
9295 
            self.success.append(_elem79)
5944 mandeep.dh 9296 
          iprot.readListEnd()
9297 
        else:
9298 
          iprot.skip(ftype)
9299 
      elif fid == 1:
9300 
        if ftype == TType.STRUCT:
9301 
          self.cex = CatalogServiceException()
9302 
          self.cex.read(iprot)
9303 
        else:
9304 
          iprot.skip(ftype)
9305 
      else:
9306 
        iprot.skip(ftype)
9307 
      iprot.readFieldEnd()
9308 
    iprot.readStructEnd()
9309 
 
9310 
  def write(self, oprot):
9311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9313 
      return
9314 
    oprot.writeStructBegin('getAllItemsInRange_result')
9315 
    if self.success is not None:
9316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9318 
      for iter80 in self.success:
9319 
        iter80.write(oprot)
5944 mandeep.dh 9320 
      oprot.writeListEnd()
9321 
      oprot.writeFieldEnd()
9322 
    if self.cex is not None:
9323 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9324 
      self.cex.write(oprot)
9325 
      oprot.writeFieldEnd()
9326 
    oprot.writeFieldStop()
9327 
    oprot.writeStructEnd()
9328 
 
9329 
  def validate(self):
9330 
    return
9331 
 
9332 
 
9333 
  def __repr__(self):
9334 
    L = ['%s=%r' % (key, value)
9335 
      for key, value in self.__dict__.iteritems()]
9336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9337 
 
9338 
  def __eq__(self, other):
9339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9340 
 
9341 
  def __ne__(self, other):
9342 
    return not (self == other)
9343 
 
9344 
class getAllItemsByStatusInRange_args:
9345 
  """
9346 
  Attributes:
9347 
   - itemStatus
9348 
   - offset
9349 
   - limit
9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    None, # 0
9354 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9355 
    (2, TType.I64, 'offset', None, None, ), # 2
9356 
    (3, TType.I64, 'limit', None, None, ), # 3
9357 
  )
9358 
 
9359 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9360 
    self.itemStatus = itemStatus
9361 
    self.offset = offset
9362 
    self.limit = limit
9363 
 
9364 
  def read(self, iprot):
9365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9367 
      return
9368 
    iprot.readStructBegin()
9369 
    while True:
9370 
      (fname, ftype, fid) = iprot.readFieldBegin()
9371 
      if ftype == TType.STOP:
9372 
        break
9373 
      if fid == 1:
9374 
        if ftype == TType.I32:
9375 
          self.itemStatus = iprot.readI32();
9376 
        else:
9377 
          iprot.skip(ftype)
9378 
      elif fid == 2:
9379 
        if ftype == TType.I64:
9380 
          self.offset = iprot.readI64();
9381 
        else:
9382 
          iprot.skip(ftype)
9383 
      elif fid == 3:
9384 
        if ftype == TType.I64:
9385 
          self.limit = iprot.readI64();
9386 
        else:
9387 
          iprot.skip(ftype)
9388 
      else:
9389 
        iprot.skip(ftype)
9390 
      iprot.readFieldEnd()
9391 
    iprot.readStructEnd()
9392 
 
9393 
  def write(self, oprot):
9394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9396 
      return
9397 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9398 
    if self.itemStatus is not None:
9399 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9400 
      oprot.writeI32(self.itemStatus)
9401 
      oprot.writeFieldEnd()
9402 
    if self.offset is not None:
9403 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9404 
      oprot.writeI64(self.offset)
9405 
      oprot.writeFieldEnd()
9406 
    if self.limit is not None:
9407 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9408 
      oprot.writeI64(self.limit)
9409 
      oprot.writeFieldEnd()
9410 
    oprot.writeFieldStop()
9411 
    oprot.writeStructEnd()
9412 
 
9413 
  def validate(self):
9414 
    return
9415 
 
9416 
 
9417 
  def __repr__(self):
9418 
    L = ['%s=%r' % (key, value)
9419 
      for key, value in self.__dict__.iteritems()]
9420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9421 
 
9422 
  def __eq__(self, other):
9423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9424 
 
9425 
  def __ne__(self, other):
9426 
    return not (self == other)
9427 
 
9428 
class getAllItemsByStatusInRange_result:
9429 
  """
9430 
  Attributes:
9431 
   - success
9432 
   - cex
9433 
  """
9434 
 
9435 
  thrift_spec = (
9436 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9437 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9438 
  )
9439 
 
9440 
  def __init__(self, success=None, cex=None,):
9441 
    self.success = success
9442 
    self.cex = cex
9443 
 
9444 
  def read(self, iprot):
9445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9447 
      return
9448 
    iprot.readStructBegin()
9449 
    while True:
9450 
      (fname, ftype, fid) = iprot.readFieldBegin()
9451 
      if ftype == TType.STOP:
9452 
        break
9453 
      if fid == 0:
9454 
        if ftype == TType.LIST:
9455 
          self.success = []
8590 kshitij.so 9456 
          (_etype84, _size81) = iprot.readListBegin()
9457 
          for _i85 in xrange(_size81):
9458 
            _elem86 = Item()
9459 
            _elem86.read(iprot)
9460 
            self.success.append(_elem86)
5944 mandeep.dh 9461 
          iprot.readListEnd()
9462 
        else:
9463 
          iprot.skip(ftype)
9464 
      elif fid == 1:
9465 
        if ftype == TType.STRUCT:
9466 
          self.cex = CatalogServiceException()
9467 
          self.cex.read(iprot)
9468 
        else:
9469 
          iprot.skip(ftype)
9470 
      else:
9471 
        iprot.skip(ftype)
9472 
      iprot.readFieldEnd()
9473 
    iprot.readStructEnd()
9474 
 
9475 
  def write(self, oprot):
9476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9478 
      return
9479 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9480 
    if self.success is not None:
9481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9483 
      for iter87 in self.success:
9484 
        iter87.write(oprot)
5944 mandeep.dh 9485 
      oprot.writeListEnd()
9486 
      oprot.writeFieldEnd()
9487 
    if self.cex is not None:
9488 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9489 
      self.cex.write(oprot)
9490 
      oprot.writeFieldEnd()
9491 
    oprot.writeFieldStop()
9492 
    oprot.writeStructEnd()
9493 
 
9494 
  def validate(self):
9495 
    return
9496 
 
9497 
 
9498 
  def __repr__(self):
9499 
    L = ['%s=%r' % (key, value)
9500 
      for key, value in self.__dict__.iteritems()]
9501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9502 
 
9503 
  def __eq__(self, other):
9504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9505 
 
9506 
  def __ne__(self, other):
9507 
    return not (self == other)
9508 
 
9509 
class getItemCountByStatus_args:
9510 
  """
9511 
  Attributes:
9512 
   - useStatus
9513 
   - itemStatus
9514 
  """
9515 
 
9516 
  thrift_spec = (
9517 
    None, # 0
9518 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9519 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9520 
  )
9521 
 
9522 
  def __init__(self, useStatus=None, itemStatus=None,):
9523 
    self.useStatus = useStatus
9524 
    self.itemStatus = itemStatus
9525 
 
9526 
  def read(self, iprot):
9527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9529 
      return
9530 
    iprot.readStructBegin()
9531 
    while True:
9532 
      (fname, ftype, fid) = iprot.readFieldBegin()
9533 
      if ftype == TType.STOP:
9534 
        break
9535 
      if fid == 1:
9536 
        if ftype == TType.BOOL:
9537 
          self.useStatus = iprot.readBool();
9538 
        else:
9539 
          iprot.skip(ftype)
9540 
      elif fid == 2:
9541 
        if ftype == TType.I32:
9542 
          self.itemStatus = iprot.readI32();
9543 
        else:
9544 
          iprot.skip(ftype)
9545 
      else:
9546 
        iprot.skip(ftype)
9547 
      iprot.readFieldEnd()
9548 
    iprot.readStructEnd()
9549 
 
9550 
  def write(self, oprot):
9551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9553 
      return
9554 
    oprot.writeStructBegin('getItemCountByStatus_args')
9555 
    if self.useStatus is not None:
9556 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9557 
      oprot.writeBool(self.useStatus)
9558 
      oprot.writeFieldEnd()
9559 
    if self.itemStatus is not None:
9560 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9561 
      oprot.writeI32(self.itemStatus)
9562 
      oprot.writeFieldEnd()
9563 
    oprot.writeFieldStop()
9564 
    oprot.writeStructEnd()
9565 
 
9566 
  def validate(self):
9567 
    return
9568 
 
9569 
 
9570 
  def __repr__(self):
9571 
    L = ['%s=%r' % (key, value)
9572 
      for key, value in self.__dict__.iteritems()]
9573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9574 
 
9575 
  def __eq__(self, other):
9576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9577 
 
9578 
  def __ne__(self, other):
9579 
    return not (self == other)
9580 
 
9581 
class getItemCountByStatus_result:
9582 
  """
9583 
  Attributes:
9584 
   - success
9585 
  """
9586 
 
9587 
  thrift_spec = (
9588 
    (0, TType.I32, 'success', None, None, ), # 0
9589 
  )
9590 
 
9591 
  def __init__(self, success=None,):
9592 
    self.success = success
9593 
 
9594 
  def read(self, iprot):
9595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9597 
      return
9598 
    iprot.readStructBegin()
9599 
    while True:
9600 
      (fname, ftype, fid) = iprot.readFieldBegin()
9601 
      if ftype == TType.STOP:
9602 
        break
9603 
      if fid == 0:
9604 
        if ftype == TType.I32:
9605 
          self.success = iprot.readI32();
9606 
        else:
9607 
          iprot.skip(ftype)
9608 
      else:
9609 
        iprot.skip(ftype)
9610 
      iprot.readFieldEnd()
9611 
    iprot.readStructEnd()
9612 
 
9613 
  def write(self, oprot):
9614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9616 
      return
9617 
    oprot.writeStructBegin('getItemCountByStatus_result')
9618 
    if self.success is not None:
9619 
      oprot.writeFieldBegin('success', TType.I32, 0)
9620 
      oprot.writeI32(self.success)
9621 
      oprot.writeFieldEnd()
9622 
    oprot.writeFieldStop()
9623 
    oprot.writeStructEnd()
9624 
 
9625 
  def validate(self):
9626 
    return
9627 
 
9628 
 
9629 
  def __repr__(self):
9630 
    L = ['%s=%r' % (key, value)
9631 
      for key, value in self.__dict__.iteritems()]
9632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9633 
 
9634 
  def __eq__(self, other):
9635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9636 
 
9637 
  def __ne__(self, other):
9638 
    return not (self == other)
9639 
 
9640 
class getBestSellers_args:
9641 
 
9642 
  thrift_spec = (
9643 
  )
9644 
 
9645 
  def read(self, iprot):
9646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9648 
      return
9649 
    iprot.readStructBegin()
9650 
    while True:
9651 
      (fname, ftype, fid) = iprot.readFieldBegin()
9652 
      if ftype == TType.STOP:
9653 
        break
9654 
      else:
9655 
        iprot.skip(ftype)
9656 
      iprot.readFieldEnd()
9657 
    iprot.readStructEnd()
9658 
 
9659 
  def write(self, oprot):
9660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9662 
      return
9663 
    oprot.writeStructBegin('getBestSellers_args')
9664 
    oprot.writeFieldStop()
9665 
    oprot.writeStructEnd()
9666 
 
9667 
  def validate(self):
9668 
    return
9669 
 
9670 
 
9671 
  def __repr__(self):
9672 
    L = ['%s=%r' % (key, value)
9673 
      for key, value in self.__dict__.iteritems()]
9674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9675 
 
9676 
  def __eq__(self, other):
9677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9678 
 
9679 
  def __ne__(self, other):
9680 
    return not (self == other)
9681 
 
9682 
class getBestSellers_result:
9683 
  """
9684 
  Attributes:
9685 
   - success
9686 
   - isex
9687 
  """
9688 
 
9689 
  thrift_spec = (
9690 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9691 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9692 
  )
9693 
 
9694 
  def __init__(self, success=None, isex=None,):
9695 
    self.success = success
9696 
    self.isex = isex
9697 
 
9698 
  def read(self, iprot):
9699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9701 
      return
9702 
    iprot.readStructBegin()
9703 
    while True:
9704 
      (fname, ftype, fid) = iprot.readFieldBegin()
9705 
      if ftype == TType.STOP:
9706 
        break
9707 
      if fid == 0:
9708 
        if ftype == TType.LIST:
9709 
          self.success = []
8590 kshitij.so 9710 
          (_etype91, _size88) = iprot.readListBegin()
9711 
          for _i92 in xrange(_size88):
9712 
            _elem93 = Item()
9713 
            _elem93.read(iprot)
9714 
            self.success.append(_elem93)
5944 mandeep.dh 9715 
          iprot.readListEnd()
9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      elif fid == 1:
9719 
        if ftype == TType.STRUCT:
9720 
          self.isex = CatalogServiceException()
9721 
          self.isex.read(iprot)
9722 
        else:
9723 
          iprot.skip(ftype)
9724 
      else:
9725 
        iprot.skip(ftype)
9726 
      iprot.readFieldEnd()
9727 
    iprot.readStructEnd()
9728 
 
9729 
  def write(self, oprot):
9730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9732 
      return
9733 
    oprot.writeStructBegin('getBestSellers_result')
9734 
    if self.success is not None:
9735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9737 
      for iter94 in self.success:
9738 
        iter94.write(oprot)
5944 mandeep.dh 9739 
      oprot.writeListEnd()
9740 
      oprot.writeFieldEnd()
9741 
    if self.isex is not None:
9742 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9743 
      self.isex.write(oprot)
9744 
      oprot.writeFieldEnd()
9745 
    oprot.writeFieldStop()
9746 
    oprot.writeStructEnd()
9747 
 
9748 
  def validate(self):
9749 
    return
9750 
 
9751 
 
9752 
  def __repr__(self):
9753 
    L = ['%s=%r' % (key, value)
9754 
      for key, value in self.__dict__.iteritems()]
9755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9756 
 
9757 
  def __eq__(self, other):
9758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9759 
 
9760 
  def __ne__(self, other):
9761 
    return not (self == other)
9762 
 
9763 
class getBestSellersCatalogIds_args:
9764 
  """
9765 
  Attributes:
9766 
   - beginIndex
9767 
   - totalItems
9768 
   - brand
9769 
   - category
9770 
  """
9771 
 
9772 
  thrift_spec = (
9773 
    None, # 0
9774 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9775 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9776 
    (3, TType.STRING, 'brand', None, None, ), # 3
9777 
    (4, TType.I64, 'category', None, None, ), # 4
9778 
  )
9779 
 
9780 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9781 
    self.beginIndex = beginIndex
9782 
    self.totalItems = totalItems
9783 
    self.brand = brand
9784 
    self.category = category
9785 
 
9786 
  def read(self, iprot):
9787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9789 
      return
9790 
    iprot.readStructBegin()
9791 
    while True:
9792 
      (fname, ftype, fid) = iprot.readFieldBegin()
9793 
      if ftype == TType.STOP:
9794 
        break
9795 
      if fid == 1:
9796 
        if ftype == TType.I64:
9797 
          self.beginIndex = iprot.readI64();
9798 
        else:
9799 
          iprot.skip(ftype)
9800 
      elif fid == 2:
9801 
        if ftype == TType.I64:
9802 
          self.totalItems = iprot.readI64();
9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      elif fid == 3:
9806 
        if ftype == TType.STRING:
9807 
          self.brand = iprot.readString();
9808 
        else:
9809 
          iprot.skip(ftype)
9810 
      elif fid == 4:
9811 
        if ftype == TType.I64:
9812 
          self.category = iprot.readI64();
9813 
        else:
9814 
          iprot.skip(ftype)
9815 
      else:
9816 
        iprot.skip(ftype)
9817 
      iprot.readFieldEnd()
9818 
    iprot.readStructEnd()
9819 
 
9820 
  def write(self, oprot):
9821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9823 
      return
9824 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9825 
    if self.beginIndex is not None:
9826 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9827 
      oprot.writeI64(self.beginIndex)
9828 
      oprot.writeFieldEnd()
9829 
    if self.totalItems is not None:
9830 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9831 
      oprot.writeI64(self.totalItems)
9832 
      oprot.writeFieldEnd()
9833 
    if self.brand is not None:
9834 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9835 
      oprot.writeString(self.brand)
9836 
      oprot.writeFieldEnd()
9837 
    if self.category is not None:
9838 
      oprot.writeFieldBegin('category', TType.I64, 4)
9839 
      oprot.writeI64(self.category)
9840 
      oprot.writeFieldEnd()
9841 
    oprot.writeFieldStop()
9842 
    oprot.writeStructEnd()
9843 
 
9844 
  def validate(self):
9845 
    return
9846 
 
9847 
 
9848 
  def __repr__(self):
9849 
    L = ['%s=%r' % (key, value)
9850 
      for key, value in self.__dict__.iteritems()]
9851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9852 
 
9853 
  def __eq__(self, other):
9854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9855 
 
9856 
  def __ne__(self, other):
9857 
    return not (self == other)
9858 
 
9859 
class getBestSellersCatalogIds_result:
9860 
  """
9861 
  Attributes:
9862 
   - success
9863 
   - cex
9864 
  """
9865 
 
9866 
  thrift_spec = (
9867 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9868 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9869 
  )
9870 
 
9871 
  def __init__(self, success=None, cex=None,):
9872 
    self.success = success
9873 
    self.cex = cex
9874 
 
9875 
  def read(self, iprot):
9876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9878 
      return
9879 
    iprot.readStructBegin()
9880 
    while True:
9881 
      (fname, ftype, fid) = iprot.readFieldBegin()
9882 
      if ftype == TType.STOP:
9883 
        break
9884 
      if fid == 0:
9885 
        if ftype == TType.LIST:
9886 
          self.success = []
8590 kshitij.so 9887 
          (_etype98, _size95) = iprot.readListBegin()
9888 
          for _i99 in xrange(_size95):
9889 
            _elem100 = iprot.readI64();
9890 
            self.success.append(_elem100)
5944 mandeep.dh 9891 
          iprot.readListEnd()
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      elif fid == 1:
9895 
        if ftype == TType.STRUCT:
9896 
          self.cex = CatalogServiceException()
9897 
          self.cex.read(iprot)
9898 
        else:
9899 
          iprot.skip(ftype)
9900 
      else:
9901 
        iprot.skip(ftype)
9902 
      iprot.readFieldEnd()
9903 
    iprot.readStructEnd()
9904 
 
9905 
  def write(self, oprot):
9906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9908 
      return
9909 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9910 
    if self.success is not None:
9911 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9912 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9913 
      for iter101 in self.success:
9914 
        oprot.writeI64(iter101)
5944 mandeep.dh 9915 
      oprot.writeListEnd()
9916 
      oprot.writeFieldEnd()
9917 
    if self.cex is not None:
9918 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9919 
      self.cex.write(oprot)
9920 
      oprot.writeFieldEnd()
9921 
    oprot.writeFieldStop()
9922 
    oprot.writeStructEnd()
9923 
 
9924 
  def validate(self):
9925 
    return
9926 
 
9927 
 
9928 
  def __repr__(self):
9929 
    L = ['%s=%r' % (key, value)
9930 
      for key, value in self.__dict__.iteritems()]
9931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9932 
 
9933 
  def __eq__(self, other):
9934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9935 
 
9936 
  def __ne__(self, other):
9937 
    return not (self == other)
9938 
 
9939 
class getBestSellersCount_args:
9940 
 
9941 
  thrift_spec = (
9942 
  )
9943 
 
9944 
  def read(self, iprot):
9945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9947 
      return
9948 
    iprot.readStructBegin()
9949 
    while True:
9950 
      (fname, ftype, fid) = iprot.readFieldBegin()
9951 
      if ftype == TType.STOP:
9952 
        break
9953 
      else:
9954 
        iprot.skip(ftype)
9955 
      iprot.readFieldEnd()
9956 
    iprot.readStructEnd()
9957 
 
9958 
  def write(self, oprot):
9959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9961 
      return
9962 
    oprot.writeStructBegin('getBestSellersCount_args')
9963 
    oprot.writeFieldStop()
9964 
    oprot.writeStructEnd()
9965 
 
9966 
  def validate(self):
9967 
    return
9968 
 
9969 
 
9970 
  def __repr__(self):
9971 
    L = ['%s=%r' % (key, value)
9972 
      for key, value in self.__dict__.iteritems()]
9973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9974 
 
9975 
  def __eq__(self, other):
9976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9977 
 
9978 
  def __ne__(self, other):
9979 
    return not (self == other)
9980 
 
9981 
class getBestSellersCount_result:
9982 
  """
9983 
  Attributes:
9984 
   - success
9985 
   - cex
9986 
  """
9987 
 
9988 
  thrift_spec = (
9989 
    (0, TType.I64, 'success', None, None, ), # 0
9990 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9991 
  )
9992 
 
9993 
  def __init__(self, success=None, cex=None,):
9994 
    self.success = success
9995 
    self.cex = cex
9996 
 
9997 
  def read(self, iprot):
9998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10000 
      return
10001 
    iprot.readStructBegin()
10002 
    while True:
10003 
      (fname, ftype, fid) = iprot.readFieldBegin()
10004 
      if ftype == TType.STOP:
10005 
        break
10006 
      if fid == 0:
10007 
        if ftype == TType.I64:
10008 
          self.success = iprot.readI64();
10009 
        else:
10010 
          iprot.skip(ftype)
10011 
      elif fid == 1:
10012 
        if ftype == TType.STRUCT:
10013 
          self.cex = CatalogServiceException()
10014 
          self.cex.read(iprot)
10015 
        else:
10016 
          iprot.skip(ftype)
10017 
      else:
10018 
        iprot.skip(ftype)
10019 
      iprot.readFieldEnd()
10020 
    iprot.readStructEnd()
10021 
 
10022 
  def write(self, oprot):
10023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10025 
      return
10026 
    oprot.writeStructBegin('getBestSellersCount_result')
10027 
    if self.success is not None:
10028 
      oprot.writeFieldBegin('success', TType.I64, 0)
10029 
      oprot.writeI64(self.success)
10030 
      oprot.writeFieldEnd()
10031 
    if self.cex is not None:
10032 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10033 
      self.cex.write(oprot)
10034 
      oprot.writeFieldEnd()
10035 
    oprot.writeFieldStop()
10036 
    oprot.writeStructEnd()
10037 
 
10038 
  def validate(self):
10039 
    return
10040 
 
10041 
 
10042 
  def __repr__(self):
10043 
    L = ['%s=%r' % (key, value)
10044 
      for key, value in self.__dict__.iteritems()]
10045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10046 
 
10047 
  def __eq__(self, other):
10048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10049 
 
10050 
  def __ne__(self, other):
10051 
    return not (self == other)
10052 
 
10053 
class getBestDeals_args:
10054 
 
10055 
  thrift_spec = (
10056 
  )
10057 
 
10058 
  def read(self, iprot):
10059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10061 
      return
10062 
    iprot.readStructBegin()
10063 
    while True:
10064 
      (fname, ftype, fid) = iprot.readFieldBegin()
10065 
      if ftype == TType.STOP:
10066 
        break
10067 
      else:
10068 
        iprot.skip(ftype)
10069 
      iprot.readFieldEnd()
10070 
    iprot.readStructEnd()
10071 
 
10072 
  def write(self, oprot):
10073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10075 
      return
10076 
    oprot.writeStructBegin('getBestDeals_args')
10077 
    oprot.writeFieldStop()
10078 
    oprot.writeStructEnd()
10079 
 
10080 
  def validate(self):
10081 
    return
10082 
 
10083 
 
10084 
  def __repr__(self):
10085 
    L = ['%s=%r' % (key, value)
10086 
      for key, value in self.__dict__.iteritems()]
10087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10088 
 
10089 
  def __eq__(self, other):
10090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10091 
 
10092 
  def __ne__(self, other):
10093 
    return not (self == other)
10094 
 
10095 
class getBestDeals_result:
10096 
  """
10097 
  Attributes:
10098 
   - success
10099 
   - isex
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10104 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10105 
  )
10106 
 
10107 
  def __init__(self, success=None, isex=None,):
10108 
    self.success = success
10109 
    self.isex = isex
10110 
 
10111 
  def read(self, iprot):
10112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10114 
      return
10115 
    iprot.readStructBegin()
10116 
    while True:
10117 
      (fname, ftype, fid) = iprot.readFieldBegin()
10118 
      if ftype == TType.STOP:
10119 
        break
10120 
      if fid == 0:
10121 
        if ftype == TType.LIST:
10122 
          self.success = []
8590 kshitij.so 10123 
          (_etype105, _size102) = iprot.readListBegin()
10124 
          for _i106 in xrange(_size102):
10125 
            _elem107 = Item()
10126 
            _elem107.read(iprot)
10127 
            self.success.append(_elem107)
5944 mandeep.dh 10128 
          iprot.readListEnd()
10129 
        else:
10130 
          iprot.skip(ftype)
10131 
      elif fid == 1:
10132 
        if ftype == TType.STRUCT:
10133 
          self.isex = CatalogServiceException()
10134 
          self.isex.read(iprot)
10135 
        else:
10136 
          iprot.skip(ftype)
10137 
      else:
10138 
        iprot.skip(ftype)
10139 
      iprot.readFieldEnd()
10140 
    iprot.readStructEnd()
10141 
 
10142 
  def write(self, oprot):
10143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10145 
      return
10146 
    oprot.writeStructBegin('getBestDeals_result')
10147 
    if self.success is not None:
10148 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10149 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10150 
      for iter108 in self.success:
10151 
        iter108.write(oprot)
5944 mandeep.dh 10152 
      oprot.writeListEnd()
10153 
      oprot.writeFieldEnd()
10154 
    if self.isex is not None:
10155 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10156 
      self.isex.write(oprot)
10157 
      oprot.writeFieldEnd()
10158 
    oprot.writeFieldStop()
10159 
    oprot.writeStructEnd()
10160 
 
10161 
  def validate(self):
10162 
    return
10163 
 
10164 
 
10165 
  def __repr__(self):
10166 
    L = ['%s=%r' % (key, value)
10167 
      for key, value in self.__dict__.iteritems()]
10168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10169 
 
10170 
  def __eq__(self, other):
10171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10172 
 
10173 
  def __ne__(self, other):
10174 
    return not (self == other)
10175 
 
10176 
class getBestDealsCatalogIds_args:
10177 
  """
10178 
  Attributes:
10179 
   - beginIndex
10180 
   - totalItems
10181 
   - brand
10182 
   - category
10183 
  """
10184 
 
10185 
  thrift_spec = (
10186 
    None, # 0
10187 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10188 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10189 
    (3, TType.STRING, 'brand', None, None, ), # 3
10190 
    (4, TType.I64, 'category', None, None, ), # 4
10191 
  )
10192 
 
10193 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10194 
    self.beginIndex = beginIndex
10195 
    self.totalItems = totalItems
10196 
    self.brand = brand
10197 
    self.category = category
10198 
 
10199 
  def read(self, iprot):
10200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10202 
      return
10203 
    iprot.readStructBegin()
10204 
    while True:
10205 
      (fname, ftype, fid) = iprot.readFieldBegin()
10206 
      if ftype == TType.STOP:
10207 
        break
10208 
      if fid == 1:
10209 
        if ftype == TType.I64:
10210 
          self.beginIndex = iprot.readI64();
10211 
        else:
10212 
          iprot.skip(ftype)
10213 
      elif fid == 2:
10214 
        if ftype == TType.I64:
10215 
          self.totalItems = iprot.readI64();
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      elif fid == 3:
10219 
        if ftype == TType.STRING:
10220 
          self.brand = iprot.readString();
10221 
        else:
10222 
          iprot.skip(ftype)
10223 
      elif fid == 4:
10224 
        if ftype == TType.I64:
10225 
          self.category = iprot.readI64();
10226 
        else:
10227 
          iprot.skip(ftype)
10228 
      else:
10229 
        iprot.skip(ftype)
10230 
      iprot.readFieldEnd()
10231 
    iprot.readStructEnd()
10232 
 
10233 
  def write(self, oprot):
10234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10236 
      return
10237 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10238 
    if self.beginIndex is not None:
10239 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10240 
      oprot.writeI64(self.beginIndex)
10241 
      oprot.writeFieldEnd()
10242 
    if self.totalItems is not None:
10243 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10244 
      oprot.writeI64(self.totalItems)
10245 
      oprot.writeFieldEnd()
10246 
    if self.brand is not None:
10247 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10248 
      oprot.writeString(self.brand)
10249 
      oprot.writeFieldEnd()
10250 
    if self.category is not None:
10251 
      oprot.writeFieldBegin('category', TType.I64, 4)
10252 
      oprot.writeI64(self.category)
10253 
      oprot.writeFieldEnd()
10254 
    oprot.writeFieldStop()
10255 
    oprot.writeStructEnd()
10256 
 
10257 
  def validate(self):
10258 
    return
10259 
 
10260 
 
10261 
  def __repr__(self):
10262 
    L = ['%s=%r' % (key, value)
10263 
      for key, value in self.__dict__.iteritems()]
10264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10265 
 
10266 
  def __eq__(self, other):
10267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10268 
 
10269 
  def __ne__(self, other):
10270 
    return not (self == other)
10271 
 
10272 
class getBestDealsCatalogIds_result:
10273 
  """
10274 
  Attributes:
10275 
   - success
10276 
   - cex
10277 
  """
10278 
 
10279 
  thrift_spec = (
10280 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10281 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10282 
  )
10283 
 
10284 
  def __init__(self, success=None, cex=None,):
10285 
    self.success = success
10286 
    self.cex = cex
10287 
 
10288 
  def read(self, iprot):
10289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10291 
      return
10292 
    iprot.readStructBegin()
10293 
    while True:
10294 
      (fname, ftype, fid) = iprot.readFieldBegin()
10295 
      if ftype == TType.STOP:
10296 
        break
10297 
      if fid == 0:
10298 
        if ftype == TType.LIST:
10299 
          self.success = []
8590 kshitij.so 10300 
          (_etype112, _size109) = iprot.readListBegin()
10301 
          for _i113 in xrange(_size109):
10302 
            _elem114 = iprot.readI64();
10303 
            self.success.append(_elem114)
5944 mandeep.dh 10304 
          iprot.readListEnd()
10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      elif fid == 1:
10308 
        if ftype == TType.STRUCT:
10309 
          self.cex = CatalogServiceException()
10310 
          self.cex.read(iprot)
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
10322 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10323 
    if self.success is not None:
10324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10325 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10326 
      for iter115 in self.success:
10327 
        oprot.writeI64(iter115)
5944 mandeep.dh 10328 
      oprot.writeListEnd()
10329 
      oprot.writeFieldEnd()
10330 
    if self.cex is not None:
10331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10332 
      self.cex.write(oprot)
10333 
      oprot.writeFieldEnd()
10334 
    oprot.writeFieldStop()
10335 
    oprot.writeStructEnd()
10336 
 
10337 
  def validate(self):
10338 
    return
10339 
 
10340 
 
10341 
  def __repr__(self):
10342 
    L = ['%s=%r' % (key, value)
10343 
      for key, value in self.__dict__.iteritems()]
10344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10345 
 
10346 
  def __eq__(self, other):
10347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10348 
 
10349 
  def __ne__(self, other):
10350 
    return not (self == other)
10351 
 
10352 
class getBestDealsCount_args:
10353 
 
10354 
  thrift_spec = (
10355 
  )
10356 
 
10357 
  def read(self, iprot):
10358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10360 
      return
10361 
    iprot.readStructBegin()
10362 
    while True:
10363 
      (fname, ftype, fid) = iprot.readFieldBegin()
10364 
      if ftype == TType.STOP:
10365 
        break
10366 
      else:
10367 
        iprot.skip(ftype)
10368 
      iprot.readFieldEnd()
10369 
    iprot.readStructEnd()
10370 
 
10371 
  def write(self, oprot):
10372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10374 
      return
10375 
    oprot.writeStructBegin('getBestDealsCount_args')
10376 
    oprot.writeFieldStop()
10377 
    oprot.writeStructEnd()
10378 
 
10379 
  def validate(self):
10380 
    return
10381 
 
10382 
 
10383 
  def __repr__(self):
10384 
    L = ['%s=%r' % (key, value)
10385 
      for key, value in self.__dict__.iteritems()]
10386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10387 
 
10388 
  def __eq__(self, other):
10389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10390 
 
10391 
  def __ne__(self, other):
10392 
    return not (self == other)
10393 
 
10394 
class getBestDealsCount_result:
10395 
  """
10396 
  Attributes:
10397 
   - success
10398 
   - cex
10399 
  """
10400 
 
10401 
  thrift_spec = (
10402 
    (0, TType.I64, 'success', None, None, ), # 0
10403 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10404 
  )
10405 
 
10406 
  def __init__(self, success=None, cex=None,):
10407 
    self.success = success
10408 
    self.cex = cex
10409 
 
10410 
  def read(self, iprot):
10411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10413 
      return
10414 
    iprot.readStructBegin()
10415 
    while True:
10416 
      (fname, ftype, fid) = iprot.readFieldBegin()
10417 
      if ftype == TType.STOP:
10418 
        break
10419 
      if fid == 0:
10420 
        if ftype == TType.I64:
10421 
          self.success = iprot.readI64();
10422 
        else:
10423 
          iprot.skip(ftype)
10424 
      elif fid == 1:
10425 
        if ftype == TType.STRUCT:
10426 
          self.cex = CatalogServiceException()
10427 
          self.cex.read(iprot)
10428 
        else:
10429 
          iprot.skip(ftype)
10430 
      else:
10431 
        iprot.skip(ftype)
10432 
      iprot.readFieldEnd()
10433 
    iprot.readStructEnd()
10434 
 
10435 
  def write(self, oprot):
10436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10438 
      return
10439 
    oprot.writeStructBegin('getBestDealsCount_result')
10440 
    if self.success is not None:
10441 
      oprot.writeFieldBegin('success', TType.I64, 0)
10442 
      oprot.writeI64(self.success)
10443 
      oprot.writeFieldEnd()
10444 
    if self.cex is not None:
10445 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10446 
      self.cex.write(oprot)
10447 
      oprot.writeFieldEnd()
10448 
    oprot.writeFieldStop()
10449 
    oprot.writeStructEnd()
10450 
 
10451 
  def validate(self):
10452 
    return
10453 
 
10454 
 
10455 
  def __repr__(self):
10456 
    L = ['%s=%r' % (key, value)
10457 
      for key, value in self.__dict__.iteritems()]
10458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10459 
 
10460 
  def __eq__(self, other):
10461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10462 
 
10463 
  def __ne__(self, other):
10464 
    return not (self == other)
10465 
 
10466 
class getComingSoon_args:
10467 
 
10468 
  thrift_spec = (
10469 
  )
10470 
 
10471 
  def read(self, iprot):
10472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10474 
      return
10475 
    iprot.readStructBegin()
10476 
    while True:
10477 
      (fname, ftype, fid) = iprot.readFieldBegin()
10478 
      if ftype == TType.STOP:
10479 
        break
10480 
      else:
10481 
        iprot.skip(ftype)
10482 
      iprot.readFieldEnd()
10483 
    iprot.readStructEnd()
10484 
 
10485 
  def write(self, oprot):
10486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10488 
      return
10489 
    oprot.writeStructBegin('getComingSoon_args')
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
10508 
class getComingSoon_result:
10509 
  """
10510 
  Attributes:
10511 
   - success
10512 
   - isex
10513 
  """
10514 
 
10515 
  thrift_spec = (
10516 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10517 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10518 
  )
10519 
 
10520 
  def __init__(self, success=None, isex=None,):
10521 
    self.success = success
10522 
    self.isex = isex
10523 
 
10524 
  def read(self, iprot):
10525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10527 
      return
10528 
    iprot.readStructBegin()
10529 
    while True:
10530 
      (fname, ftype, fid) = iprot.readFieldBegin()
10531 
      if ftype == TType.STOP:
10532 
        break
10533 
      if fid == 0:
10534 
        if ftype == TType.LIST:
10535 
          self.success = []
8590 kshitij.so 10536 
          (_etype119, _size116) = iprot.readListBegin()
10537 
          for _i120 in xrange(_size116):
10538 
            _elem121 = Item()
10539 
            _elem121.read(iprot)
10540 
            self.success.append(_elem121)
5944 mandeep.dh 10541 
          iprot.readListEnd()
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      elif fid == 1:
10545 
        if ftype == TType.STRUCT:
10546 
          self.isex = CatalogServiceException()
10547 
          self.isex.read(iprot)
10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
10559 
    oprot.writeStructBegin('getComingSoon_result')
10560 
    if self.success is not None:
10561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10563 
      for iter122 in self.success:
10564 
        iter122.write(oprot)
5944 mandeep.dh 10565 
      oprot.writeListEnd()
10566 
      oprot.writeFieldEnd()
10567 
    if self.isex is not None:
10568 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10569 
      self.isex.write(oprot)
10570 
      oprot.writeFieldEnd()
10571 
    oprot.writeFieldStop()
10572 
    oprot.writeStructEnd()
10573 
 
10574 
  def validate(self):
10575 
    return
10576 
 
10577 
 
10578 
  def __repr__(self):
10579 
    L = ['%s=%r' % (key, value)
10580 
      for key, value in self.__dict__.iteritems()]
10581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10582 
 
10583 
  def __eq__(self, other):
10584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10585 
 
10586 
  def __ne__(self, other):
10587 
    return not (self == other)
10588 
 
10589 
class getComingSoonCatalogIds_args:
10590 
  """
10591 
  Attributes:
10592 
   - beginIndex
10593 
   - totalItems
10594 
   - brand
10595 
   - category
10596 
  """
10597 
 
10598 
  thrift_spec = (
10599 
    None, # 0
10600 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10601 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10602 
    (3, TType.STRING, 'brand', None, None, ), # 3
10603 
    (4, TType.I64, 'category', None, None, ), # 4
10604 
  )
10605 
 
10606 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10607 
    self.beginIndex = beginIndex
10608 
    self.totalItems = totalItems
10609 
    self.brand = brand
10610 
    self.category = category
10611 
 
10612 
  def read(self, iprot):
10613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10615 
      return
10616 
    iprot.readStructBegin()
10617 
    while True:
10618 
      (fname, ftype, fid) = iprot.readFieldBegin()
10619 
      if ftype == TType.STOP:
10620 
        break
10621 
      if fid == 1:
10622 
        if ftype == TType.I64:
10623 
          self.beginIndex = iprot.readI64();
10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      elif fid == 2:
10627 
        if ftype == TType.I64:
10628 
          self.totalItems = iprot.readI64();
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      elif fid == 3:
10632 
        if ftype == TType.STRING:
10633 
          self.brand = iprot.readString();
10634 
        else:
10635 
          iprot.skip(ftype)
10636 
      elif fid == 4:
10637 
        if ftype == TType.I64:
10638 
          self.category = iprot.readI64();
10639 
        else:
10640 
          iprot.skip(ftype)
10641 
      else:
10642 
        iprot.skip(ftype)
10643 
      iprot.readFieldEnd()
10644 
    iprot.readStructEnd()
10645 
 
10646 
  def write(self, oprot):
10647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10649 
      return
10650 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10651 
    if self.beginIndex is not None:
10652 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10653 
      oprot.writeI64(self.beginIndex)
10654 
      oprot.writeFieldEnd()
10655 
    if self.totalItems is not None:
10656 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10657 
      oprot.writeI64(self.totalItems)
10658 
      oprot.writeFieldEnd()
10659 
    if self.brand is not None:
10660 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10661 
      oprot.writeString(self.brand)
10662 
      oprot.writeFieldEnd()
10663 
    if self.category is not None:
10664 
      oprot.writeFieldBegin('category', TType.I64, 4)
10665 
      oprot.writeI64(self.category)
10666 
      oprot.writeFieldEnd()
10667 
    oprot.writeFieldStop()
10668 
    oprot.writeStructEnd()
10669 
 
10670 
  def validate(self):
10671 
    return
10672 
 
10673 
 
10674 
  def __repr__(self):
10675 
    L = ['%s=%r' % (key, value)
10676 
      for key, value in self.__dict__.iteritems()]
10677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10678 
 
10679 
  def __eq__(self, other):
10680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10681 
 
10682 
  def __ne__(self, other):
10683 
    return not (self == other)
10684 
 
10685 
class getComingSoonCatalogIds_result:
10686 
  """
10687 
  Attributes:
10688 
   - success
10689 
   - cex
10690 
  """
10691 
 
10692 
  thrift_spec = (
10693 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10694 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10695 
  )
10696 
 
10697 
  def __init__(self, success=None, cex=None,):
10698 
    self.success = success
10699 
    self.cex = cex
10700 
 
10701 
  def read(self, iprot):
10702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10704 
      return
10705 
    iprot.readStructBegin()
10706 
    while True:
10707 
      (fname, ftype, fid) = iprot.readFieldBegin()
10708 
      if ftype == TType.STOP:
10709 
        break
10710 
      if fid == 0:
10711 
        if ftype == TType.LIST:
10712 
          self.success = []
8590 kshitij.so 10713 
          (_etype126, _size123) = iprot.readListBegin()
10714 
          for _i127 in xrange(_size123):
10715 
            _elem128 = iprot.readI64();
10716 
            self.success.append(_elem128)
5944 mandeep.dh 10717 
          iprot.readListEnd()
10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      elif fid == 1:
10721 
        if ftype == TType.STRUCT:
10722 
          self.cex = CatalogServiceException()
10723 
          self.cex.read(iprot)
10724 
        else:
10725 
          iprot.skip(ftype)
10726 
      else:
10727 
        iprot.skip(ftype)
10728 
      iprot.readFieldEnd()
10729 
    iprot.readStructEnd()
10730 
 
10731 
  def write(self, oprot):
10732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10734 
      return
10735 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10736 
    if self.success is not None:
10737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10738 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10739 
      for iter129 in self.success:
10740 
        oprot.writeI64(iter129)
5944 mandeep.dh 10741 
      oprot.writeListEnd()
10742 
      oprot.writeFieldEnd()
10743 
    if self.cex is not None:
10744 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10745 
      self.cex.write(oprot)
10746 
      oprot.writeFieldEnd()
10747 
    oprot.writeFieldStop()
10748 
    oprot.writeStructEnd()
10749 
 
10750 
  def validate(self):
10751 
    return
10752 
 
10753 
 
10754 
  def __repr__(self):
10755 
    L = ['%s=%r' % (key, value)
10756 
      for key, value in self.__dict__.iteritems()]
10757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10758 
 
10759 
  def __eq__(self, other):
10760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10761 
 
10762 
  def __ne__(self, other):
10763 
    return not (self == other)
10764 
 
10765 
class getComingSoonCount_args:
10766 
 
10767 
  thrift_spec = (
10768 
  )
10769 
 
10770 
  def read(self, iprot):
10771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10773 
      return
10774 
    iprot.readStructBegin()
10775 
    while True:
10776 
      (fname, ftype, fid) = iprot.readFieldBegin()
10777 
      if ftype == TType.STOP:
10778 
        break
10779 
      else:
10780 
        iprot.skip(ftype)
10781 
      iprot.readFieldEnd()
10782 
    iprot.readStructEnd()
10783 
 
10784 
  def write(self, oprot):
10785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10787 
      return
10788 
    oprot.writeStructBegin('getComingSoonCount_args')
10789 
    oprot.writeFieldStop()
10790 
    oprot.writeStructEnd()
10791 
 
10792 
  def validate(self):
10793 
    return
10794 
 
10795 
 
10796 
  def __repr__(self):
10797 
    L = ['%s=%r' % (key, value)
10798 
      for key, value in self.__dict__.iteritems()]
10799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10800 
 
10801 
  def __eq__(self, other):
10802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10803 
 
10804 
  def __ne__(self, other):
10805 
    return not (self == other)
10806 
 
10807 
class getComingSoonCount_result:
10808 
  """
10809 
  Attributes:
10810 
   - success
10811 
   - cex
10812 
  """
10813 
 
10814 
  thrift_spec = (
10815 
    (0, TType.I64, 'success', None, None, ), # 0
10816 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10817 
  )
10818 
 
10819 
  def __init__(self, success=None, cex=None,):
10820 
    self.success = success
10821 
    self.cex = cex
10822 
 
10823 
  def read(self, iprot):
10824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10826 
      return
10827 
    iprot.readStructBegin()
10828 
    while True:
10829 
      (fname, ftype, fid) = iprot.readFieldBegin()
10830 
      if ftype == TType.STOP:
10831 
        break
10832 
      if fid == 0:
10833 
        if ftype == TType.I64:
10834 
          self.success = iprot.readI64();
10835 
        else:
10836 
          iprot.skip(ftype)
10837 
      elif fid == 1:
10838 
        if ftype == TType.STRUCT:
10839 
          self.cex = CatalogServiceException()
10840 
          self.cex.read(iprot)
10841 
        else:
10842 
          iprot.skip(ftype)
10843 
      else:
10844 
        iprot.skip(ftype)
10845 
      iprot.readFieldEnd()
10846 
    iprot.readStructEnd()
10847 
 
10848 
  def write(self, oprot):
10849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10851 
      return
10852 
    oprot.writeStructBegin('getComingSoonCount_result')
10853 
    if self.success is not None:
10854 
      oprot.writeFieldBegin('success', TType.I64, 0)
10855 
      oprot.writeI64(self.success)
10856 
      oprot.writeFieldEnd()
10857 
    if self.cex is not None:
10858 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10859 
      self.cex.write(oprot)
10860 
      oprot.writeFieldEnd()
10861 
    oprot.writeFieldStop()
10862 
    oprot.writeStructEnd()
10863 
 
10864 
  def validate(self):
10865 
    return
10866 
 
10867 
 
10868 
  def __repr__(self):
10869 
    L = ['%s=%r' % (key, value)
10870 
      for key, value in self.__dict__.iteritems()]
10871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10872 
 
10873 
  def __eq__(self, other):
10874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10875 
 
10876 
  def __ne__(self, other):
10877 
    return not (self == other)
10878 
 
10879 
class getLatestArrivals_args:
10880 
 
10881 
  thrift_spec = (
10882 
  )
10883 
 
10884 
  def read(self, iprot):
10885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10887 
      return
10888 
    iprot.readStructBegin()
10889 
    while True:
10890 
      (fname, ftype, fid) = iprot.readFieldBegin()
10891 
      if ftype == TType.STOP:
10892 
        break
10893 
      else:
10894 
        iprot.skip(ftype)
10895 
      iprot.readFieldEnd()
10896 
    iprot.readStructEnd()
10897 
 
10898 
  def write(self, oprot):
10899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10901 
      return
10902 
    oprot.writeStructBegin('getLatestArrivals_args')
10903 
    oprot.writeFieldStop()
10904 
    oprot.writeStructEnd()
10905 
 
10906 
  def validate(self):
10907 
    return
10908 
 
10909 
 
10910 
  def __repr__(self):
10911 
    L = ['%s=%r' % (key, value)
10912 
      for key, value in self.__dict__.iteritems()]
10913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10914 
 
10915 
  def __eq__(self, other):
10916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10917 
 
10918 
  def __ne__(self, other):
10919 
    return not (self == other)
10920 
 
10921 
class getLatestArrivals_result:
10922 
  """
10923 
  Attributes:
10924 
   - success
10925 
   - isex
10926 
  """
10927 
 
10928 
  thrift_spec = (
10929 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10930 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10931 
  )
10932 
 
10933 
  def __init__(self, success=None, isex=None,):
10934 
    self.success = success
10935 
    self.isex = isex
10936 
 
10937 
  def read(self, iprot):
10938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10940 
      return
10941 
    iprot.readStructBegin()
10942 
    while True:
10943 
      (fname, ftype, fid) = iprot.readFieldBegin()
10944 
      if ftype == TType.STOP:
10945 
        break
10946 
      if fid == 0:
10947 
        if ftype == TType.LIST:
10948 
          self.success = []
8590 kshitij.so 10949 
          (_etype133, _size130) = iprot.readListBegin()
10950 
          for _i134 in xrange(_size130):
10951 
            _elem135 = Item()
10952 
            _elem135.read(iprot)
10953 
            self.success.append(_elem135)
5944 mandeep.dh 10954 
          iprot.readListEnd()
10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      elif fid == 1:
10958 
        if ftype == TType.STRUCT:
10959 
          self.isex = CatalogServiceException()
10960 
          self.isex.read(iprot)
10961 
        else:
10962 
          iprot.skip(ftype)
10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
10972 
    oprot.writeStructBegin('getLatestArrivals_result')
10973 
    if self.success is not None:
10974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10976 
      for iter136 in self.success:
10977 
        iter136.write(oprot)
5944 mandeep.dh 10978 
      oprot.writeListEnd()
10979 
      oprot.writeFieldEnd()
10980 
    if self.isex is not None:
10981 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10982 
      self.isex.write(oprot)
10983 
      oprot.writeFieldEnd()
10984 
    oprot.writeFieldStop()
10985 
    oprot.writeStructEnd()
10986 
 
10987 
  def validate(self):
10988 
    return
10989 
 
10990 
 
10991 
  def __repr__(self):
10992 
    L = ['%s=%r' % (key, value)
10993 
      for key, value in self.__dict__.iteritems()]
10994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10995 
 
10996 
  def __eq__(self, other):
10997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10998 
 
10999 
  def __ne__(self, other):
11000 
    return not (self == other)
11001 
 
11002 
class getLatestArrivalsCatalogIds_args:
11003 
  """
11004 
  Attributes:
11005 
   - beginIndex
11006 
   - totalItems
11007 
   - brand
11008 
   - categories
11009 
  """
11010 
 
11011 
  thrift_spec = (
11012 
    None, # 0
11013 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11014 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11015 
    (3, TType.STRING, 'brand', None, None, ), # 3
11016 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11017 
  )
11018 
 
11019 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11020 
    self.beginIndex = beginIndex
11021 
    self.totalItems = totalItems
11022 
    self.brand = brand
11023 
    self.categories = categories
11024 
 
11025 
  def read(self, iprot):
11026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11028 
      return
11029 
    iprot.readStructBegin()
11030 
    while True:
11031 
      (fname, ftype, fid) = iprot.readFieldBegin()
11032 
      if ftype == TType.STOP:
11033 
        break
11034 
      if fid == 1:
11035 
        if ftype == TType.I64:
11036 
          self.beginIndex = iprot.readI64();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      elif fid == 2:
11040 
        if ftype == TType.I64:
11041 
          self.totalItems = iprot.readI64();
11042 
        else:
11043 
          iprot.skip(ftype)
11044 
      elif fid == 3:
11045 
        if ftype == TType.STRING:
11046 
          self.brand = iprot.readString();
11047 
        else:
11048 
          iprot.skip(ftype)
11049 
      elif fid == 4:
11050 
        if ftype == TType.LIST:
11051 
          self.categories = []
8590 kshitij.so 11052 
          (_etype140, _size137) = iprot.readListBegin()
11053 
          for _i141 in xrange(_size137):
11054 
            _elem142 = iprot.readI64();
11055 
            self.categories.append(_elem142)
5944 mandeep.dh 11056 
          iprot.readListEnd()
11057 
        else:
11058 
          iprot.skip(ftype)
11059 
      else:
11060 
        iprot.skip(ftype)
11061 
      iprot.readFieldEnd()
11062 
    iprot.readStructEnd()
11063 
 
11064 
  def write(self, oprot):
11065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11067 
      return
11068 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11069 
    if self.beginIndex is not None:
11070 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11071 
      oprot.writeI64(self.beginIndex)
11072 
      oprot.writeFieldEnd()
11073 
    if self.totalItems is not None:
11074 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11075 
      oprot.writeI64(self.totalItems)
11076 
      oprot.writeFieldEnd()
11077 
    if self.brand is not None:
11078 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11079 
      oprot.writeString(self.brand)
11080 
      oprot.writeFieldEnd()
11081 
    if self.categories is not None:
11082 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11083 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11084 
      for iter143 in self.categories:
11085 
        oprot.writeI64(iter143)
5944 mandeep.dh 11086 
      oprot.writeListEnd()
11087 
      oprot.writeFieldEnd()
11088 
    oprot.writeFieldStop()
11089 
    oprot.writeStructEnd()
11090 
 
11091 
  def validate(self):
11092 
    return
11093 
 
11094 
 
11095 
  def __repr__(self):
11096 
    L = ['%s=%r' % (key, value)
11097 
      for key, value in self.__dict__.iteritems()]
11098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11099 
 
11100 
  def __eq__(self, other):
11101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11102 
 
11103 
  def __ne__(self, other):
11104 
    return not (self == other)
11105 
 
11106 
class getLatestArrivalsCatalogIds_result:
11107 
  """
11108 
  Attributes:
11109 
   - success
11110 
   - cex
11111 
  """
11112 
 
11113 
  thrift_spec = (
11114 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11115 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11116 
  )
11117 
 
11118 
  def __init__(self, success=None, cex=None,):
11119 
    self.success = success
11120 
    self.cex = cex
11121 
 
11122 
  def read(self, iprot):
11123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11125 
      return
11126 
    iprot.readStructBegin()
11127 
    while True:
11128 
      (fname, ftype, fid) = iprot.readFieldBegin()
11129 
      if ftype == TType.STOP:
11130 
        break
11131 
      if fid == 0:
11132 
        if ftype == TType.LIST:
11133 
          self.success = []
8590 kshitij.so 11134 
          (_etype147, _size144) = iprot.readListBegin()
11135 
          for _i148 in xrange(_size144):
11136 
            _elem149 = iprot.readI64();
11137 
            self.success.append(_elem149)
5944 mandeep.dh 11138 
          iprot.readListEnd()
11139 
        else:
11140 
          iprot.skip(ftype)
11141 
      elif fid == 1:
11142 
        if ftype == TType.STRUCT:
11143 
          self.cex = CatalogServiceException()
11144 
          self.cex.read(iprot)
11145 
        else:
11146 
          iprot.skip(ftype)
11147 
      else:
11148 
        iprot.skip(ftype)
11149 
      iprot.readFieldEnd()
11150 
    iprot.readStructEnd()
11151 
 
11152 
  def write(self, oprot):
11153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11155 
      return
11156 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11157 
    if self.success is not None:
11158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11159 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11160 
      for iter150 in self.success:
11161 
        oprot.writeI64(iter150)
5944 mandeep.dh 11162 
      oprot.writeListEnd()
11163 
      oprot.writeFieldEnd()
11164 
    if self.cex is not None:
11165 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11166 
      self.cex.write(oprot)
11167 
      oprot.writeFieldEnd()
11168 
    oprot.writeFieldStop()
11169 
    oprot.writeStructEnd()
11170 
 
11171 
  def validate(self):
11172 
    return
11173 
 
11174 
 
11175 
  def __repr__(self):
11176 
    L = ['%s=%r' % (key, value)
11177 
      for key, value in self.__dict__.iteritems()]
11178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11179 
 
11180 
  def __eq__(self, other):
11181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11182 
 
11183 
  def __ne__(self, other):
11184 
    return not (self == other)
11185 
 
11186 
class getLatestArrivalsCount_args:
11187 
 
11188 
  thrift_spec = (
11189 
  )
11190 
 
11191 
  def read(self, iprot):
11192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11194 
      return
11195 
    iprot.readStructBegin()
11196 
    while True:
11197 
      (fname, ftype, fid) = iprot.readFieldBegin()
11198 
      if ftype == TType.STOP:
11199 
        break
11200 
      else:
11201 
        iprot.skip(ftype)
11202 
      iprot.readFieldEnd()
11203 
    iprot.readStructEnd()
11204 
 
11205 
  def write(self, oprot):
11206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11208 
      return
11209 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11210 
    oprot.writeFieldStop()
11211 
    oprot.writeStructEnd()
11212 
 
11213 
  def validate(self):
11214 
    return
11215 
 
11216 
 
11217 
  def __repr__(self):
11218 
    L = ['%s=%r' % (key, value)
11219 
      for key, value in self.__dict__.iteritems()]
11220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11221 
 
11222 
  def __eq__(self, other):
11223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11224 
 
11225 
  def __ne__(self, other):
11226 
    return not (self == other)
11227 
 
11228 
class getLatestArrivalsCount_result:
11229 
  """
11230 
  Attributes:
11231 
   - success
11232 
   - cex
11233 
  """
11234 
 
11235 
  thrift_spec = (
11236 
    (0, TType.I64, 'success', None, None, ), # 0
11237 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11238 
  )
11239 
 
11240 
  def __init__(self, success=None, cex=None,):
11241 
    self.success = success
11242 
    self.cex = cex
11243 
 
11244 
  def read(self, iprot):
11245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11247 
      return
11248 
    iprot.readStructBegin()
11249 
    while True:
11250 
      (fname, ftype, fid) = iprot.readFieldBegin()
11251 
      if ftype == TType.STOP:
11252 
        break
11253 
      if fid == 0:
11254 
        if ftype == TType.I64:
11255 
          self.success = iprot.readI64();
11256 
        else:
11257 
          iprot.skip(ftype)
11258 
      elif fid == 1:
11259 
        if ftype == TType.STRUCT:
11260 
          self.cex = CatalogServiceException()
11261 
          self.cex.read(iprot)
11262 
        else:
11263 
          iprot.skip(ftype)
11264 
      else:
11265 
        iprot.skip(ftype)
11266 
      iprot.readFieldEnd()
11267 
    iprot.readStructEnd()
11268 
 
11269 
  def write(self, oprot):
11270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11272 
      return
11273 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11274 
    if self.success is not None:
11275 
      oprot.writeFieldBegin('success', TType.I64, 0)
11276 
      oprot.writeI64(self.success)
11277 
      oprot.writeFieldEnd()
11278 
    if self.cex is not None:
11279 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11280 
      self.cex.write(oprot)
11281 
      oprot.writeFieldEnd()
11282 
    oprot.writeFieldStop()
11283 
    oprot.writeStructEnd()
11284 
 
11285 
  def validate(self):
11286 
    return
11287 
 
11288 
 
11289 
  def __repr__(self):
11290 
    L = ['%s=%r' % (key, value)
11291 
      for key, value in self.__dict__.iteritems()]
11292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11293 
 
11294 
  def __eq__(self, other):
11295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11296 
 
11297 
  def __ne__(self, other):
11298 
    return not (self == other)
11299 
 
11300 
class generateNewEntityID_args:
11301 
 
11302 
  thrift_spec = (
11303 
  )
11304 
 
11305 
  def read(self, iprot):
11306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11308 
      return
11309 
    iprot.readStructBegin()
11310 
    while True:
11311 
      (fname, ftype, fid) = iprot.readFieldBegin()
11312 
      if ftype == TType.STOP:
11313 
        break
11314 
      else:
11315 
        iprot.skip(ftype)
11316 
      iprot.readFieldEnd()
11317 
    iprot.readStructEnd()
11318 
 
11319 
  def write(self, oprot):
11320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11322 
      return
11323 
    oprot.writeStructBegin('generateNewEntityID_args')
11324 
    oprot.writeFieldStop()
11325 
    oprot.writeStructEnd()
11326 
 
11327 
  def validate(self):
11328 
    return
11329 
 
11330 
 
11331 
  def __repr__(self):
11332 
    L = ['%s=%r' % (key, value)
11333 
      for key, value in self.__dict__.iteritems()]
11334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11335 
 
11336 
  def __eq__(self, other):
11337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11338 
 
11339 
  def __ne__(self, other):
11340 
    return not (self == other)
11341 
 
11342 
class generateNewEntityID_result:
11343 
  """
11344 
  Attributes:
11345 
   - success
11346 
  """
11347 
 
11348 
  thrift_spec = (
11349 
    (0, TType.I64, 'success', None, None, ), # 0
11350 
  )
11351 
 
11352 
  def __init__(self, success=None,):
11353 
    self.success = success
11354 
 
11355 
  def read(self, iprot):
11356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11358 
      return
11359 
    iprot.readStructBegin()
11360 
    while True:
11361 
      (fname, ftype, fid) = iprot.readFieldBegin()
11362 
      if ftype == TType.STOP:
11363 
        break
11364 
      if fid == 0:
11365 
        if ftype == TType.I64:
11366 
          self.success = iprot.readI64();
11367 
        else:
11368 
          iprot.skip(ftype)
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_result')
11379 
    if self.success is not None:
11380 
      oprot.writeFieldBegin('success', TType.I64, 0)
11381 
      oprot.writeI64(self.success)
11382 
      oprot.writeFieldEnd()
11383 
    oprot.writeFieldStop()
11384 
    oprot.writeStructEnd()
11385 
 
11386 
  def validate(self):
11387 
    return
11388 
 
11389 
 
11390 
  def __repr__(self):
11391 
    L = ['%s=%r' % (key, value)
11392 
      for key, value in self.__dict__.iteritems()]
11393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11394 
 
11395 
  def __eq__(self, other):
11396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11397 
 
11398 
  def __ne__(self, other):
11399 
    return not (self == other)
11400 
 
11401 
class addCategory_args:
11402 
  """
11403 
  Attributes:
11404 
   - category
11405 
  """
11406 
 
11407 
  thrift_spec = (
11408 
    None, # 0
11409 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11410 
  )
11411 
 
11412 
  def __init__(self, category=None,):
11413 
    self.category = category
11414 
 
11415 
  def read(self, iprot):
11416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11418 
      return
11419 
    iprot.readStructBegin()
11420 
    while True:
11421 
      (fname, ftype, fid) = iprot.readFieldBegin()
11422 
      if ftype == TType.STOP:
11423 
        break
11424 
      if fid == 1:
11425 
        if ftype == TType.STRUCT:
11426 
          self.category = Category()
11427 
          self.category.read(iprot)
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      else:
11431 
        iprot.skip(ftype)
11432 
      iprot.readFieldEnd()
11433 
    iprot.readStructEnd()
11434 
 
11435 
  def write(self, oprot):
11436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11438 
      return
11439 
    oprot.writeStructBegin('addCategory_args')
11440 
    if self.category is not None:
11441 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11442 
      self.category.write(oprot)
11443 
      oprot.writeFieldEnd()
11444 
    oprot.writeFieldStop()
11445 
    oprot.writeStructEnd()
11446 
 
11447 
  def validate(self):
11448 
    return
11449 
 
11450 
 
11451 
  def __repr__(self):
11452 
    L = ['%s=%r' % (key, value)
11453 
      for key, value in self.__dict__.iteritems()]
11454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11455 
 
11456 
  def __eq__(self, other):
11457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11458 
 
11459 
  def __ne__(self, other):
11460 
    return not (self == other)
11461 
 
11462 
class addCategory_result:
11463 
  """
11464 
  Attributes:
11465 
   - success
11466 
  """
11467 
 
11468 
  thrift_spec = (
11469 
    (0, TType.BOOL, 'success', None, None, ), # 0
11470 
  )
11471 
 
11472 
  def __init__(self, success=None,):
11473 
    self.success = success
11474 
 
11475 
  def read(self, iprot):
11476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11478 
      return
11479 
    iprot.readStructBegin()
11480 
    while True:
11481 
      (fname, ftype, fid) = iprot.readFieldBegin()
11482 
      if ftype == TType.STOP:
11483 
        break
11484 
      if fid == 0:
11485 
        if ftype == TType.BOOL:
11486 
          self.success = iprot.readBool();
11487 
        else:
11488 
          iprot.skip(ftype)
11489 
      else:
11490 
        iprot.skip(ftype)
11491 
      iprot.readFieldEnd()
11492 
    iprot.readStructEnd()
11493 
 
11494 
  def write(self, oprot):
11495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11497 
      return
11498 
    oprot.writeStructBegin('addCategory_result')
11499 
    if self.success is not None:
11500 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11501 
      oprot.writeBool(self.success)
11502 
      oprot.writeFieldEnd()
11503 
    oprot.writeFieldStop()
11504 
    oprot.writeStructEnd()
11505 
 
11506 
  def validate(self):
11507 
    return
11508 
 
11509 
 
11510 
  def __repr__(self):
11511 
    L = ['%s=%r' % (key, value)
11512 
      for key, value in self.__dict__.iteritems()]
11513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11514 
 
11515 
  def __eq__(self, other):
11516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11517 
 
11518 
  def __ne__(self, other):
11519 
    return not (self == other)
11520 
 
11521 
class getCategory_args:
11522 
  """
11523 
  Attributes:
11524 
   - id
11525 
  """
11526 
 
11527 
  thrift_spec = (
11528 
    None, # 0
11529 
    (1, TType.I64, 'id', None, None, ), # 1
11530 
  )
11531 
 
11532 
  def __init__(self, id=None,):
11533 
    self.id = id
11534 
 
11535 
  def read(self, iprot):
11536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11538 
      return
11539 
    iprot.readStructBegin()
11540 
    while True:
11541 
      (fname, ftype, fid) = iprot.readFieldBegin()
11542 
      if ftype == TType.STOP:
11543 
        break
11544 
      if fid == 1:
11545 
        if ftype == TType.I64:
11546 
          self.id = iprot.readI64();
11547 
        else:
11548 
          iprot.skip(ftype)
11549 
      else:
11550 
        iprot.skip(ftype)
11551 
      iprot.readFieldEnd()
11552 
    iprot.readStructEnd()
11553 
 
11554 
  def write(self, oprot):
11555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11557 
      return
11558 
    oprot.writeStructBegin('getCategory_args')
11559 
    if self.id is not None:
11560 
      oprot.writeFieldBegin('id', TType.I64, 1)
11561 
      oprot.writeI64(self.id)
11562 
      oprot.writeFieldEnd()
11563 
    oprot.writeFieldStop()
11564 
    oprot.writeStructEnd()
11565 
 
11566 
  def validate(self):
11567 
    return
11568 
 
11569 
 
11570 
  def __repr__(self):
11571 
    L = ['%s=%r' % (key, value)
11572 
      for key, value in self.__dict__.iteritems()]
11573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11574 
 
11575 
  def __eq__(self, other):
11576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11577 
 
11578 
  def __ne__(self, other):
11579 
    return not (self == other)
11580 
 
11581 
class getCategory_result:
11582 
  """
11583 
  Attributes:
11584 
   - success
11585 
  """
11586 
 
11587 
  thrift_spec = (
11588 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11589 
  )
11590 
 
11591 
  def __init__(self, success=None,):
11592 
    self.success = success
11593 
 
11594 
  def read(self, iprot):
11595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11597 
      return
11598 
    iprot.readStructBegin()
11599 
    while True:
11600 
      (fname, ftype, fid) = iprot.readFieldBegin()
11601 
      if ftype == TType.STOP:
11602 
        break
11603 
      if fid == 0:
11604 
        if ftype == TType.STRUCT:
11605 
          self.success = Category()
11606 
          self.success.read(iprot)
11607 
        else:
11608 
          iprot.skip(ftype)
11609 
      else:
11610 
        iprot.skip(ftype)
11611 
      iprot.readFieldEnd()
11612 
    iprot.readStructEnd()
11613 
 
11614 
  def write(self, oprot):
11615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11617 
      return
11618 
    oprot.writeStructBegin('getCategory_result')
11619 
    if self.success is not None:
11620 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11621 
      self.success.write(oprot)
11622 
      oprot.writeFieldEnd()
11623 
    oprot.writeFieldStop()
11624 
    oprot.writeStructEnd()
11625 
 
11626 
  def validate(self):
11627 
    return
11628 
 
11629 
 
11630 
  def __repr__(self):
11631 
    L = ['%s=%r' % (key, value)
11632 
      for key, value in self.__dict__.iteritems()]
11633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11634 
 
11635 
  def __eq__(self, other):
11636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11637 
 
11638 
  def __ne__(self, other):
11639 
    return not (self == other)
11640 
 
11641 
class getAllCategories_args:
11642 
 
11643 
  thrift_spec = (
11644 
  )
11645 
 
11646 
  def read(self, iprot):
11647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11649 
      return
11650 
    iprot.readStructBegin()
11651 
    while True:
11652 
      (fname, ftype, fid) = iprot.readFieldBegin()
11653 
      if ftype == TType.STOP:
11654 
        break
11655 
      else:
11656 
        iprot.skip(ftype)
11657 
      iprot.readFieldEnd()
11658 
    iprot.readStructEnd()
11659 
 
11660 
  def write(self, oprot):
11661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11663 
      return
11664 
    oprot.writeStructBegin('getAllCategories_args')
11665 
    oprot.writeFieldStop()
11666 
    oprot.writeStructEnd()
11667 
 
11668 
  def validate(self):
11669 
    return
11670 
 
11671 
 
11672 
  def __repr__(self):
11673 
    L = ['%s=%r' % (key, value)
11674 
      for key, value in self.__dict__.iteritems()]
11675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11676 
 
11677 
  def __eq__(self, other):
11678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11679 
 
11680 
  def __ne__(self, other):
11681 
    return not (self == other)
11682 
 
11683 
class getAllCategories_result:
11684 
  """
11685 
  Attributes:
11686 
   - success
11687 
  """
11688 
 
11689 
  thrift_spec = (
11690 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11691 
  )
11692 
 
11693 
  def __init__(self, success=None,):
11694 
    self.success = success
11695 
 
11696 
  def read(self, iprot):
11697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11699 
      return
11700 
    iprot.readStructBegin()
11701 
    while True:
11702 
      (fname, ftype, fid) = iprot.readFieldBegin()
11703 
      if ftype == TType.STOP:
11704 
        break
11705 
      if fid == 0:
11706 
        if ftype == TType.LIST:
11707 
          self.success = []
8590 kshitij.so 11708 
          (_etype154, _size151) = iprot.readListBegin()
11709 
          for _i155 in xrange(_size151):
11710 
            _elem156 = Category()
11711 
            _elem156.read(iprot)
11712 
            self.success.append(_elem156)
5944 mandeep.dh 11713 
          iprot.readListEnd()
11714 
        else:
11715 
          iprot.skip(ftype)
11716 
      else:
11717 
        iprot.skip(ftype)
11718 
      iprot.readFieldEnd()
11719 
    iprot.readStructEnd()
11720 
 
11721 
  def write(self, oprot):
11722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11724 
      return
11725 
    oprot.writeStructBegin('getAllCategories_result')
11726 
    if self.success is not None:
11727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11729 
      for iter157 in self.success:
11730 
        iter157.write(oprot)
5944 mandeep.dh 11731 
      oprot.writeListEnd()
11732 
      oprot.writeFieldEnd()
11733 
    oprot.writeFieldStop()
11734 
    oprot.writeStructEnd()
11735 
 
11736 
  def validate(self):
11737 
    return
11738 
 
11739 
 
11740 
  def __repr__(self):
11741 
    L = ['%s=%r' % (key, value)
11742 
      for key, value in self.__dict__.iteritems()]
11743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11744 
 
11745 
  def __eq__(self, other):
11746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11747 
 
11748 
  def __ne__(self, other):
11749 
    return not (self == other)
11750 
 
11751 
class getAllSimilarItems_args:
11752 
  """
11753 
  Attributes:
11754 
   - itemId
11755 
  """
11756 
 
11757 
  thrift_spec = (
11758 
    None, # 0
11759 
    (1, TType.I64, 'itemId', None, None, ), # 1
11760 
  )
11761 
 
11762 
  def __init__(self, itemId=None,):
11763 
    self.itemId = itemId
11764 
 
11765 
  def read(self, iprot):
11766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11768 
      return
11769 
    iprot.readStructBegin()
11770 
    while True:
11771 
      (fname, ftype, fid) = iprot.readFieldBegin()
11772 
      if ftype == TType.STOP:
11773 
        break
11774 
      if fid == 1:
11775 
        if ftype == TType.I64:
11776 
          self.itemId = iprot.readI64();
11777 
        else:
11778 
          iprot.skip(ftype)
11779 
      else:
11780 
        iprot.skip(ftype)
11781 
      iprot.readFieldEnd()
11782 
    iprot.readStructEnd()
11783 
 
11784 
  def write(self, oprot):
11785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11787 
      return
11788 
    oprot.writeStructBegin('getAllSimilarItems_args')
11789 
    if self.itemId is not None:
11790 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11791 
      oprot.writeI64(self.itemId)
11792 
      oprot.writeFieldEnd()
11793 
    oprot.writeFieldStop()
11794 
    oprot.writeStructEnd()
11795 
 
11796 
  def validate(self):
11797 
    return
11798 
 
11799 
 
11800 
  def __repr__(self):
11801 
    L = ['%s=%r' % (key, value)
11802 
      for key, value in self.__dict__.iteritems()]
11803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11804 
 
11805 
  def __eq__(self, other):
11806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11807 
 
11808 
  def __ne__(self, other):
11809 
    return not (self == other)
11810 
 
11811 
class getAllSimilarItems_result:
11812 
  """
11813 
  Attributes:
11814 
   - success
11815 
  """
11816 
 
11817 
  thrift_spec = (
11818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11819 
  )
11820 
 
11821 
  def __init__(self, success=None,):
11822 
    self.success = success
11823 
 
11824 
  def read(self, iprot):
11825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11827 
      return
11828 
    iprot.readStructBegin()
11829 
    while True:
11830 
      (fname, ftype, fid) = iprot.readFieldBegin()
11831 
      if ftype == TType.STOP:
11832 
        break
11833 
      if fid == 0:
11834 
        if ftype == TType.LIST:
11835 
          self.success = []
8590 kshitij.so 11836 
          (_etype161, _size158) = iprot.readListBegin()
11837 
          for _i162 in xrange(_size158):
11838 
            _elem163 = Item()
11839 
            _elem163.read(iprot)
11840 
            self.success.append(_elem163)
5944 mandeep.dh 11841 
          iprot.readListEnd()
11842 
        else:
11843 
          iprot.skip(ftype)
11844 
      else:
11845 
        iprot.skip(ftype)
11846 
      iprot.readFieldEnd()
11847 
    iprot.readStructEnd()
11848 
 
11849 
  def write(self, oprot):
11850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11852 
      return
11853 
    oprot.writeStructBegin('getAllSimilarItems_result')
11854 
    if self.success is not None:
11855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11857 
      for iter164 in self.success:
11858 
        iter164.write(oprot)
5944 mandeep.dh 11859 
      oprot.writeListEnd()
11860 
      oprot.writeFieldEnd()
11861 
    oprot.writeFieldStop()
11862 
    oprot.writeStructEnd()
11863 
 
11864 
  def validate(self):
11865 
    return
11866 
 
11867 
 
11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
11879 
class addSimilarItem_args:
11880 
  """
11881 
  Attributes:
11882 
   - itemId
11883 
   - catalogItemId
11884 
  """
11885 
 
11886 
  thrift_spec = (
11887 
    None, # 0
11888 
    (1, TType.I64, 'itemId', None, None, ), # 1
11889 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11890 
  )
11891 
 
11892 
  def __init__(self, itemId=None, catalogItemId=None,):
11893 
    self.itemId = itemId
11894 
    self.catalogItemId = catalogItemId
11895 
 
11896 
  def read(self, iprot):
11897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11899 
      return
11900 
    iprot.readStructBegin()
11901 
    while True:
11902 
      (fname, ftype, fid) = iprot.readFieldBegin()
11903 
      if ftype == TType.STOP:
11904 
        break
11905 
      if fid == 1:
11906 
        if ftype == TType.I64:
11907 
          self.itemId = iprot.readI64();
11908 
        else:
11909 
          iprot.skip(ftype)
11910 
      elif fid == 2:
11911 
        if ftype == TType.I64:
11912 
          self.catalogItemId = iprot.readI64();
11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      else:
11916 
        iprot.skip(ftype)
11917 
      iprot.readFieldEnd()
11918 
    iprot.readStructEnd()
11919 
 
11920 
  def write(self, oprot):
11921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11923 
      return
11924 
    oprot.writeStructBegin('addSimilarItem_args')
11925 
    if self.itemId is not None:
11926 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11927 
      oprot.writeI64(self.itemId)
11928 
      oprot.writeFieldEnd()
11929 
    if self.catalogItemId is not None:
11930 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11931 
      oprot.writeI64(self.catalogItemId)
11932 
      oprot.writeFieldEnd()
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
11951 
class addSimilarItem_result:
11952 
  """
11953 
  Attributes:
11954 
   - success
11955 
   - cex
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11960 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11961 
  )
11962 
 
11963 
  def __init__(self, success=None, cex=None,):
11964 
    self.success = success
11965 
    self.cex = cex
11966 
 
11967 
  def read(self, iprot):
11968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11970 
      return
11971 
    iprot.readStructBegin()
11972 
    while True:
11973 
      (fname, ftype, fid) = iprot.readFieldBegin()
11974 
      if ftype == TType.STOP:
11975 
        break
11976 
      if fid == 0:
11977 
        if ftype == TType.STRUCT:
11978 
          self.success = Item()
11979 
          self.success.read(iprot)
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      elif fid == 1:
11983 
        if ftype == TType.STRUCT:
11984 
          self.cex = CatalogServiceException()
11985 
          self.cex.read(iprot)
11986 
        else:
11987 
          iprot.skip(ftype)
11988 
      else:
11989 
        iprot.skip(ftype)
11990 
      iprot.readFieldEnd()
11991 
    iprot.readStructEnd()
11992 
 
11993 
  def write(self, oprot):
11994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11996 
      return
11997 
    oprot.writeStructBegin('addSimilarItem_result')
11998 
    if self.success is not None:
11999 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12000 
      self.success.write(oprot)
12001 
      oprot.writeFieldEnd()
12002 
    if self.cex is not None:
12003 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12004 
      self.cex.write(oprot)
12005 
      oprot.writeFieldEnd()
12006 
    oprot.writeFieldStop()
12007 
    oprot.writeStructEnd()
12008 
 
12009 
  def validate(self):
12010 
    return
12011 
 
12012 
 
12013 
  def __repr__(self):
12014 
    L = ['%s=%r' % (key, value)
12015 
      for key, value in self.__dict__.iteritems()]
12016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12017 
 
12018 
  def __eq__(self, other):
12019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12020 
 
12021 
  def __ne__(self, other):
12022 
    return not (self == other)
12023 
 
6512 kshitij.so 12024 
class addTag_args:
12025 
  """
12026 
  Attributes:
12027 
   - displayName
12028 
   - itemId
12029 
  """
12030 
 
12031 
  thrift_spec = (
12032 
    None, # 0
12033 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12034 
    (2, TType.I64, 'itemId', None, None, ), # 2
12035 
  )
12036 
 
12037 
  def __init__(self, displayName=None, itemId=None,):
12038 
    self.displayName = displayName
12039 
    self.itemId = itemId
12040 
 
12041 
  def read(self, iprot):
12042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12044 
      return
12045 
    iprot.readStructBegin()
12046 
    while True:
12047 
      (fname, ftype, fid) = iprot.readFieldBegin()
12048 
      if ftype == TType.STOP:
12049 
        break
12050 
      if fid == 1:
12051 
        if ftype == TType.STRING:
12052 
          self.displayName = iprot.readString();
12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      elif fid == 2:
12056 
        if ftype == TType.I64:
12057 
          self.itemId = iprot.readI64();
12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
12069 
    oprot.writeStructBegin('addTag_args')
12070 
    if self.displayName is not None:
12071 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12072 
      oprot.writeString(self.displayName)
12073 
      oprot.writeFieldEnd()
12074 
    if self.itemId is not None:
12075 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12076 
      oprot.writeI64(self.itemId)
12077 
      oprot.writeFieldEnd()
12078 
    oprot.writeFieldStop()
12079 
    oprot.writeStructEnd()
12080 
 
12081 
  def validate(self):
12082 
    return
12083 
 
12084 
 
12085 
  def __repr__(self):
12086 
    L = ['%s=%r' % (key, value)
12087 
      for key, value in self.__dict__.iteritems()]
12088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12089 
 
12090 
  def __eq__(self, other):
12091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12092 
 
12093 
  def __ne__(self, other):
12094 
    return not (self == other)
12095 
 
12096 
class addTag_result:
12097 
  """
12098 
  Attributes:
12099 
   - success
12100 
  """
12101 
 
12102 
  thrift_spec = (
12103 
    (0, TType.BOOL, 'success', None, None, ), # 0
12104 
  )
12105 
 
12106 
  def __init__(self, success=None,):
12107 
    self.success = success
12108 
 
12109 
  def read(self, iprot):
12110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12112 
      return
12113 
    iprot.readStructBegin()
12114 
    while True:
12115 
      (fname, ftype, fid) = iprot.readFieldBegin()
12116 
      if ftype == TType.STOP:
12117 
        break
12118 
      if fid == 0:
12119 
        if ftype == TType.BOOL:
12120 
          self.success = iprot.readBool();
12121 
        else:
12122 
          iprot.skip(ftype)
12123 
      else:
12124 
        iprot.skip(ftype)
12125 
      iprot.readFieldEnd()
12126 
    iprot.readStructEnd()
12127 
 
12128 
  def write(self, oprot):
12129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12131 
      return
12132 
    oprot.writeStructBegin('addTag_result')
12133 
    if self.success is not None:
12134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12135 
      oprot.writeBool(self.success)
12136 
      oprot.writeFieldEnd()
12137 
    oprot.writeFieldStop()
12138 
    oprot.writeStructEnd()
12139 
 
12140 
  def validate(self):
12141 
    return
12142 
 
12143 
 
12144 
  def __repr__(self):
12145 
    L = ['%s=%r' % (key, value)
12146 
      for key, value in self.__dict__.iteritems()]
12147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12148 
 
12149 
  def __eq__(self, other):
12150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12151 
 
12152 
  def __ne__(self, other):
12153 
    return not (self == other)
12154 
 
12155 
class deleteEntityTag_args:
12156 
  """
12157 
  Attributes:
12158 
   - displayName
12159 
   - itemId
12160 
  """
12161 
 
12162 
  thrift_spec = (
12163 
    None, # 0
12164 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12165 
    (2, TType.I64, 'itemId', None, None, ), # 2
12166 
  )
12167 
 
12168 
  def __init__(self, displayName=None, itemId=None,):
12169 
    self.displayName = displayName
12170 
    self.itemId = itemId
12171 
 
12172 
  def read(self, iprot):
12173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12175 
      return
12176 
    iprot.readStructBegin()
12177 
    while True:
12178 
      (fname, ftype, fid) = iprot.readFieldBegin()
12179 
      if ftype == TType.STOP:
12180 
        break
12181 
      if fid == 1:
12182 
        if ftype == TType.STRING:
12183 
          self.displayName = iprot.readString();
12184 
        else:
12185 
          iprot.skip(ftype)
12186 
      elif fid == 2:
12187 
        if ftype == TType.I64:
12188 
          self.itemId = iprot.readI64();
12189 
        else:
12190 
          iprot.skip(ftype)
12191 
      else:
12192 
        iprot.skip(ftype)
12193 
      iprot.readFieldEnd()
12194 
    iprot.readStructEnd()
12195 
 
12196 
  def write(self, oprot):
12197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12199 
      return
12200 
    oprot.writeStructBegin('deleteEntityTag_args')
12201 
    if self.displayName is not None:
12202 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12203 
      oprot.writeString(self.displayName)
12204 
      oprot.writeFieldEnd()
12205 
    if self.itemId is not None:
12206 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12207 
      oprot.writeI64(self.itemId)
12208 
      oprot.writeFieldEnd()
12209 
    oprot.writeFieldStop()
12210 
    oprot.writeStructEnd()
12211 
 
12212 
  def validate(self):
12213 
    return
12214 
 
12215 
 
12216 
  def __repr__(self):
12217 
    L = ['%s=%r' % (key, value)
12218 
      for key, value in self.__dict__.iteritems()]
12219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12220 
 
12221 
  def __eq__(self, other):
12222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12223 
 
12224 
  def __ne__(self, other):
12225 
    return not (self == other)
12226 
 
12227 
class deleteEntityTag_result:
12228 
  """
12229 
  Attributes:
12230 
   - success
12231 
  """
12232 
 
12233 
  thrift_spec = (
12234 
    (0, TType.BOOL, 'success', None, None, ), # 0
12235 
  )
12236 
 
12237 
  def __init__(self, success=None,):
12238 
    self.success = success
12239 
 
12240 
  def read(self, iprot):
12241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12243 
      return
12244 
    iprot.readStructBegin()
12245 
    while True:
12246 
      (fname, ftype, fid) = iprot.readFieldBegin()
12247 
      if ftype == TType.STOP:
12248 
        break
12249 
      if fid == 0:
12250 
        if ftype == TType.BOOL:
12251 
          self.success = iprot.readBool();
12252 
        else:
12253 
          iprot.skip(ftype)
12254 
      else:
12255 
        iprot.skip(ftype)
12256 
      iprot.readFieldEnd()
12257 
    iprot.readStructEnd()
12258 
 
12259 
  def write(self, oprot):
12260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12262 
      return
12263 
    oprot.writeStructBegin('deleteEntityTag_result')
12264 
    if self.success is not None:
12265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12266 
      oprot.writeBool(self.success)
12267 
      oprot.writeFieldEnd()
12268 
    oprot.writeFieldStop()
12269 
    oprot.writeStructEnd()
12270 
 
12271 
  def validate(self):
12272 
    return
12273 
 
12274 
 
12275 
  def __repr__(self):
12276 
    L = ['%s=%r' % (key, value)
12277 
      for key, value in self.__dict__.iteritems()]
12278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12279 
 
12280 
  def __eq__(self, other):
12281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12282 
 
12283 
  def __ne__(self, other):
12284 
    return not (self == other)
12285 
 
12286 
class deleteTag_args:
12287 
  """
12288 
  Attributes:
12289 
   - displayName
12290 
  """
12291 
 
12292 
  thrift_spec = (
12293 
    None, # 0
12294 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12295 
  )
12296 
 
12297 
  def __init__(self, displayName=None,):
12298 
    self.displayName = displayName
12299 
 
12300 
  def read(self, iprot):
12301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12303 
      return
12304 
    iprot.readStructBegin()
12305 
    while True:
12306 
      (fname, ftype, fid) = iprot.readFieldBegin()
12307 
      if ftype == TType.STOP:
12308 
        break
12309 
      if fid == 1:
12310 
        if ftype == TType.STRING:
12311 
          self.displayName = iprot.readString();
12312 
        else:
12313 
          iprot.skip(ftype)
12314 
      else:
12315 
        iprot.skip(ftype)
12316 
      iprot.readFieldEnd()
12317 
    iprot.readStructEnd()
12318 
 
12319 
  def write(self, oprot):
12320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12322 
      return
12323 
    oprot.writeStructBegin('deleteTag_args')
12324 
    if self.displayName is not None:
12325 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12326 
      oprot.writeString(self.displayName)
12327 
      oprot.writeFieldEnd()
12328 
    oprot.writeFieldStop()
12329 
    oprot.writeStructEnd()
12330 
 
12331 
  def validate(self):
12332 
    return
12333 
 
12334 
 
12335 
  def __repr__(self):
12336 
    L = ['%s=%r' % (key, value)
12337 
      for key, value in self.__dict__.iteritems()]
12338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12339 
 
12340 
  def __eq__(self, other):
12341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12342 
 
12343 
  def __ne__(self, other):
12344 
    return not (self == other)
12345 
 
12346 
class deleteTag_result:
12347 
  """
12348 
  Attributes:
12349 
   - success
12350 
  """
12351 
 
12352 
  thrift_spec = (
12353 
    (0, TType.BOOL, 'success', None, None, ), # 0
12354 
  )
12355 
 
12356 
  def __init__(self, success=None,):
12357 
    self.success = success
12358 
 
12359 
  def read(self, iprot):
12360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12362 
      return
12363 
    iprot.readStructBegin()
12364 
    while True:
12365 
      (fname, ftype, fid) = iprot.readFieldBegin()
12366 
      if ftype == TType.STOP:
12367 
        break
12368 
      if fid == 0:
12369 
        if ftype == TType.BOOL:
12370 
          self.success = iprot.readBool();
12371 
        else:
12372 
          iprot.skip(ftype)
12373 
      else:
12374 
        iprot.skip(ftype)
12375 
      iprot.readFieldEnd()
12376 
    iprot.readStructEnd()
12377 
 
12378 
  def write(self, oprot):
12379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12381 
      return
12382 
    oprot.writeStructBegin('deleteTag_result')
12383 
    if self.success is not None:
12384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12385 
      oprot.writeBool(self.success)
12386 
      oprot.writeFieldEnd()
12387 
    oprot.writeFieldStop()
12388 
    oprot.writeStructEnd()
12389 
 
12390 
  def validate(self):
12391 
    return
12392 
 
12393 
 
12394 
  def __repr__(self):
12395 
    L = ['%s=%r' % (key, value)
12396 
      for key, value in self.__dict__.iteritems()]
12397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12398 
 
12399 
  def __eq__(self, other):
12400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12401 
 
12402 
  def __ne__(self, other):
12403 
    return not (self == other)
12404 
 
12405 
class getAllTags_args:
12406 
 
12407 
  thrift_spec = (
12408 
  )
12409 
 
12410 
  def read(self, iprot):
12411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12413 
      return
12414 
    iprot.readStructBegin()
12415 
    while True:
12416 
      (fname, ftype, fid) = iprot.readFieldBegin()
12417 
      if ftype == TType.STOP:
12418 
        break
12419 
      else:
12420 
        iprot.skip(ftype)
12421 
      iprot.readFieldEnd()
12422 
    iprot.readStructEnd()
12423 
 
12424 
  def write(self, oprot):
12425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12427 
      return
12428 
    oprot.writeStructBegin('getAllTags_args')
12429 
    oprot.writeFieldStop()
12430 
    oprot.writeStructEnd()
12431 
 
12432 
  def validate(self):
12433 
    return
12434 
 
12435 
 
12436 
  def __repr__(self):
12437 
    L = ['%s=%r' % (key, value)
12438 
      for key, value in self.__dict__.iteritems()]
12439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12440 
 
12441 
  def __eq__(self, other):
12442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12443 
 
12444 
  def __ne__(self, other):
12445 
    return not (self == other)
12446 
 
12447 
class getAllTags_result:
12448 
  """
12449 
  Attributes:
12450 
   - success
12451 
  """
12452 
 
12453 
  thrift_spec = (
12454 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12455 
  )
12456 
 
12457 
  def __init__(self, success=None,):
12458 
    self.success = success
12459 
 
12460 
  def read(self, iprot):
12461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12463 
      return
12464 
    iprot.readStructBegin()
12465 
    while True:
12466 
      (fname, ftype, fid) = iprot.readFieldBegin()
12467 
      if ftype == TType.STOP:
12468 
        break
12469 
      if fid == 0:
12470 
        if ftype == TType.LIST:
12471 
          self.success = []
8590 kshitij.so 12472 
          (_etype168, _size165) = iprot.readListBegin()
12473 
          for _i169 in xrange(_size165):
12474 
            _elem170 = iprot.readString();
12475 
            self.success.append(_elem170)
6512 kshitij.so 12476 
          iprot.readListEnd()
12477 
        else:
12478 
          iprot.skip(ftype)
12479 
      else:
12480 
        iprot.skip(ftype)
12481 
      iprot.readFieldEnd()
12482 
    iprot.readStructEnd()
12483 
 
12484 
  def write(self, oprot):
12485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12487 
      return
12488 
    oprot.writeStructBegin('getAllTags_result')
12489 
    if self.success is not None:
12490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12491 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12492 
      for iter171 in self.success:
12493 
        oprot.writeString(iter171)
6512 kshitij.so 12494 
      oprot.writeListEnd()
12495 
      oprot.writeFieldEnd()
12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
12514 
class getAllEntitiesByTagName_args:
12515 
  """
12516 
  Attributes:
12517 
   - displayName
12518 
  """
12519 
 
12520 
  thrift_spec = (
12521 
    None, # 0
12522 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12523 
  )
12524 
 
12525 
  def __init__(self, displayName=None,):
12526 
    self.displayName = displayName
12527 
 
12528 
  def read(self, iprot):
12529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12531 
      return
12532 
    iprot.readStructBegin()
12533 
    while True:
12534 
      (fname, ftype, fid) = iprot.readFieldBegin()
12535 
      if ftype == TType.STOP:
12536 
        break
12537 
      if fid == 1:
12538 
        if ftype == TType.STRING:
12539 
          self.displayName = iprot.readString();
12540 
        else:
12541 
          iprot.skip(ftype)
12542 
      else:
12543 
        iprot.skip(ftype)
12544 
      iprot.readFieldEnd()
12545 
    iprot.readStructEnd()
12546 
 
12547 
  def write(self, oprot):
12548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12550 
      return
12551 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12552 
    if self.displayName is not None:
12553 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12554 
      oprot.writeString(self.displayName)
12555 
      oprot.writeFieldEnd()
12556 
    oprot.writeFieldStop()
12557 
    oprot.writeStructEnd()
12558 
 
12559 
  def validate(self):
12560 
    return
12561 
 
12562 
 
12563 
  def __repr__(self):
12564 
    L = ['%s=%r' % (key, value)
12565 
      for key, value in self.__dict__.iteritems()]
12566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12567 
 
12568 
  def __eq__(self, other):
12569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12570 
 
12571 
  def __ne__(self, other):
12572 
    return not (self == other)
12573 
 
12574 
class getAllEntitiesByTagName_result:
12575 
  """
12576 
  Attributes:
12577 
   - success
12578 
  """
12579 
 
12580 
  thrift_spec = (
12581 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12582 
  )
12583 
 
12584 
  def __init__(self, success=None,):
12585 
    self.success = success
12586 
 
12587 
  def read(self, iprot):
12588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12590 
      return
12591 
    iprot.readStructBegin()
12592 
    while True:
12593 
      (fname, ftype, fid) = iprot.readFieldBegin()
12594 
      if ftype == TType.STOP:
12595 
        break
12596 
      if fid == 0:
12597 
        if ftype == TType.LIST:
12598 
          self.success = []
8590 kshitij.so 12599 
          (_etype175, _size172) = iprot.readListBegin()
12600 
          for _i176 in xrange(_size172):
12601 
            _elem177 = iprot.readI64();
12602 
            self.success.append(_elem177)
6512 kshitij.so 12603 
          iprot.readListEnd()
12604 
        else:
12605 
          iprot.skip(ftype)
12606 
      else:
12607 
        iprot.skip(ftype)
12608 
      iprot.readFieldEnd()
12609 
    iprot.readStructEnd()
12610 
 
12611 
  def write(self, oprot):
12612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12614 
      return
12615 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12616 
    if self.success is not None:
12617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12618 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12619 
      for iter178 in self.success:
12620 
        oprot.writeI64(iter178)
6512 kshitij.so 12621 
      oprot.writeListEnd()
12622 
      oprot.writeFieldEnd()
12623 
    oprot.writeFieldStop()
12624 
    oprot.writeStructEnd()
12625 
 
12626 
  def validate(self):
12627 
    return
12628 
 
12629 
 
12630 
  def __repr__(self):
12631 
    L = ['%s=%r' % (key, value)
12632 
      for key, value in self.__dict__.iteritems()]
12633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12634 
 
12635 
  def __eq__(self, other):
12636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12637 
 
12638 
  def __ne__(self, other):
12639 
    return not (self == other)
12640 
 
6845 amit.gupta 12641 
class getAllEntityTags_args:
12642 
 
12643 
  thrift_spec = (
12644 
  )
12645 
 
12646 
  def read(self, iprot):
12647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12649 
      return
12650 
    iprot.readStructBegin()
12651 
    while True:
12652 
      (fname, ftype, fid) = iprot.readFieldBegin()
12653 
      if ftype == TType.STOP:
12654 
        break
12655 
      else:
12656 
        iprot.skip(ftype)
12657 
      iprot.readFieldEnd()
12658 
    iprot.readStructEnd()
12659 
 
12660 
  def write(self, oprot):
12661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12663 
      return
12664 
    oprot.writeStructBegin('getAllEntityTags_args')
12665 
    oprot.writeFieldStop()
12666 
    oprot.writeStructEnd()
12667 
 
12668 
  def validate(self):
12669 
    return
12670 
 
12671 
 
12672 
  def __repr__(self):
12673 
    L = ['%s=%r' % (key, value)
12674 
      for key, value in self.__dict__.iteritems()]
12675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12676 
 
12677 
  def __eq__(self, other):
12678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12679 
 
12680 
  def __ne__(self, other):
12681 
    return not (self == other)
12682 
 
12683 
class getAllEntityTags_result:
12684 
  """
12685 
  Attributes:
12686 
   - success
12687 
  """
12688 
 
12689 
  thrift_spec = (
12690 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12691 
  )
12692 
 
12693 
  def __init__(self, success=None,):
12694 
    self.success = success
12695 
 
12696 
  def read(self, iprot):
12697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12699 
      return
12700 
    iprot.readStructBegin()
12701 
    while True:
12702 
      (fname, ftype, fid) = iprot.readFieldBegin()
12703 
      if ftype == TType.STOP:
12704 
        break
12705 
      if fid == 0:
12706 
        if ftype == TType.MAP:
12707 
          self.success = {}
8590 kshitij.so 12708 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12709 
          for _i183 in xrange(_size179):
12710 
            _key184 = iprot.readI64();
12711 
            _val185 = []
12712 
            (_etype189, _size186) = iprot.readListBegin()
12713 
            for _i190 in xrange(_size186):
12714 
              _elem191 = iprot.readString();
12715 
              _val185.append(_elem191)
6845 amit.gupta 12716 
            iprot.readListEnd()
8590 kshitij.so 12717 
            self.success[_key184] = _val185
6845 amit.gupta 12718 
          iprot.readMapEnd()
12719 
        else:
12720 
          iprot.skip(ftype)
12721 
      else:
12722 
        iprot.skip(ftype)
12723 
      iprot.readFieldEnd()
12724 
    iprot.readStructEnd()
12725 
 
12726 
  def write(self, oprot):
12727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12729 
      return
12730 
    oprot.writeStructBegin('getAllEntityTags_result')
12731 
    if self.success is not None:
12732 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12733 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12734 
      for kiter192,viter193 in self.success.items():
12735 
        oprot.writeI64(kiter192)
12736 
        oprot.writeListBegin(TType.STRING, len(viter193))
12737 
        for iter194 in viter193:
12738 
          oprot.writeString(iter194)
6845 amit.gupta 12739 
        oprot.writeListEnd()
12740 
      oprot.writeMapEnd()
12741 
      oprot.writeFieldEnd()
12742 
    oprot.writeFieldStop()
12743 
    oprot.writeStructEnd()
12744 
 
12745 
  def validate(self):
12746 
    return
12747 
 
12748 
 
12749 
  def __repr__(self):
12750 
    L = ['%s=%r' % (key, value)
12751 
      for key, value in self.__dict__.iteritems()]
12752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12753 
 
12754 
  def __eq__(self, other):
12755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12756 
 
12757 
  def __ne__(self, other):
12758 
    return not (self == other)
12759 
 
6850 kshitij.so 12760 
class addBanner_args:
12761 
  """
12762 
  Attributes:
8590 kshitij.so 12763 
   - bannerCongregate
6850 kshitij.so 12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
8590 kshitij.so 12768 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12769 
  )
12770 
 
8590 kshitij.so 12771 
  def __init__(self, bannerCongregate=None,):
12772 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12773 
 
12774 
  def read(self, iprot):
12775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12777 
      return
12778 
    iprot.readStructBegin()
12779 
    while True:
12780 
      (fname, ftype, fid) = iprot.readFieldBegin()
12781 
      if ftype == TType.STOP:
12782 
        break
12783 
      if fid == 1:
8579 kshitij.so 12784 
        if ftype == TType.STRUCT:
8590 kshitij.so 12785 
          self.bannerCongregate = BannerCongregate()
12786 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12787 
        else:
12788 
          iprot.skip(ftype)
8579 kshitij.so 12789 
      else:
12790 
        iprot.skip(ftype)
12791 
      iprot.readFieldEnd()
12792 
    iprot.readStructEnd()
12793 
 
12794 
  def write(self, oprot):
12795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12797 
      return
12798 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12799 
    if self.bannerCongregate is not None:
12800 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12801 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12802 
      oprot.writeFieldEnd()
12803 
    oprot.writeFieldStop()
12804 
    oprot.writeStructEnd()
12805 
 
12806 
  def validate(self):
12807 
    return
12808 
 
12809 
 
12810 
  def __repr__(self):
12811 
    L = ['%s=%r' % (key, value)
12812 
      for key, value in self.__dict__.iteritems()]
12813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12814 
 
12815 
  def __eq__(self, other):
12816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12817 
 
12818 
  def __ne__(self, other):
12819 
    return not (self == other)
12820 
 
12821 
class addBanner_result:
12822 
 
12823 
  thrift_spec = (
12824 
  )
12825 
 
12826 
  def read(self, iprot):
12827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12829 
      return
12830 
    iprot.readStructBegin()
12831 
    while True:
12832 
      (fname, ftype, fid) = iprot.readFieldBegin()
12833 
      if ftype == TType.STOP:
12834 
        break
12835 
      else:
12836 
        iprot.skip(ftype)
12837 
      iprot.readFieldEnd()
12838 
    iprot.readStructEnd()
12839 
 
12840 
  def write(self, oprot):
12841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12843 
      return
12844 
    oprot.writeStructBegin('addBanner_result')
12845 
    oprot.writeFieldStop()
12846 
    oprot.writeStructEnd()
12847 
 
12848 
  def validate(self):
12849 
    return
12850 
 
12851 
 
12852 
  def __repr__(self):
12853 
    L = ['%s=%r' % (key, value)
12854 
      for key, value in self.__dict__.iteritems()]
12855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12856 
 
12857 
  def __eq__(self, other):
12858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12859 
 
12860 
  def __ne__(self, other):
12861 
    return not (self == other)
12862 
 
12863 
class updateBanner_args:
12864 
  """
12865 
  Attributes:
12866 
   - banner
12867 
  """
12868 
 
12869 
  thrift_spec = (
12870 
    None, # 0
12871 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12872 
  )
12873 
 
12874 
  def __init__(self, banner=None,):
12875 
    self.banner = banner
12876 
 
12877 
  def read(self, iprot):
12878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12880 
      return
12881 
    iprot.readStructBegin()
12882 
    while True:
12883 
      (fname, ftype, fid) = iprot.readFieldBegin()
12884 
      if ftype == TType.STOP:
12885 
        break
12886 
      if fid == 1:
12887 
        if ftype == TType.STRUCT:
12888 
          self.banner = Banner()
12889 
          self.banner.read(iprot)
6850 kshitij.so 12890 
        else:
12891 
          iprot.skip(ftype)
12892 
      else:
12893 
        iprot.skip(ftype)
12894 
      iprot.readFieldEnd()
12895 
    iprot.readStructEnd()
12896 
 
12897 
  def write(self, oprot):
12898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12900 
      return
8579 kshitij.so 12901 
    oprot.writeStructBegin('updateBanner_args')
12902 
    if self.banner is not None:
12903 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12904 
      self.banner.write(oprot)
6850 kshitij.so 12905 
      oprot.writeFieldEnd()
12906 
    oprot.writeFieldStop()
12907 
    oprot.writeStructEnd()
12908 
 
12909 
  def validate(self):
12910 
    return
12911 
 
12912 
 
12913 
  def __repr__(self):
12914 
    L = ['%s=%r' % (key, value)
12915 
      for key, value in self.__dict__.iteritems()]
12916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12917 
 
12918 
  def __eq__(self, other):
12919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12920 
 
12921 
  def __ne__(self, other):
12922 
    return not (self == other)
12923 
 
8579 kshitij.so 12924 
class updateBanner_result:
6850 kshitij.so 12925 
  """
12926 
  Attributes:
12927 
   - success
12928 
  """
12929 
 
12930 
  thrift_spec = (
12931 
    (0, TType.BOOL, 'success', None, None, ), # 0
12932 
  )
12933 
 
12934 
  def __init__(self, success=None,):
12935 
    self.success = success
12936 
 
12937 
  def read(self, iprot):
12938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12940 
      return
12941 
    iprot.readStructBegin()
12942 
    while True:
12943 
      (fname, ftype, fid) = iprot.readFieldBegin()
12944 
      if ftype == TType.STOP:
12945 
        break
12946 
      if fid == 0:
12947 
        if ftype == TType.BOOL:
12948 
          self.success = iprot.readBool();
12949 
        else:
12950 
          iprot.skip(ftype)
12951 
      else:
12952 
        iprot.skip(ftype)
12953 
      iprot.readFieldEnd()
12954 
    iprot.readStructEnd()
12955 
 
12956 
  def write(self, oprot):
12957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12959 
      return
8579 kshitij.so 12960 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12961 
    if self.success is not None:
12962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12963 
      oprot.writeBool(self.success)
12964 
      oprot.writeFieldEnd()
12965 
    oprot.writeFieldStop()
12966 
    oprot.writeStructEnd()
12967 
 
12968 
  def validate(self):
12969 
    return
12970 
 
12971 
 
12972 
  def __repr__(self):
12973 
    L = ['%s=%r' % (key, value)
12974 
      for key, value in self.__dict__.iteritems()]
12975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12976 
 
12977 
  def __eq__(self, other):
12978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12979 
 
12980 
  def __ne__(self, other):
12981 
    return not (self == other)
12982 
 
12983 
class getAllBanners_args:
12984 
 
12985 
  thrift_spec = (
12986 
  )
12987 
 
12988 
  def read(self, iprot):
12989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12991 
      return
12992 
    iprot.readStructBegin()
12993 
    while True:
12994 
      (fname, ftype, fid) = iprot.readFieldBegin()
12995 
      if ftype == TType.STOP:
12996 
        break
12997 
      else:
12998 
        iprot.skip(ftype)
12999 
      iprot.readFieldEnd()
13000 
    iprot.readStructEnd()
13001 
 
13002 
  def write(self, oprot):
13003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13005 
      return
13006 
    oprot.writeStructBegin('getAllBanners_args')
13007 
    oprot.writeFieldStop()
13008 
    oprot.writeStructEnd()
13009 
 
13010 
  def validate(self):
13011 
    return
13012 
 
13013 
 
13014 
  def __repr__(self):
13015 
    L = ['%s=%r' % (key, value)
13016 
      for key, value in self.__dict__.iteritems()]
13017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13018 
 
13019 
  def __eq__(self, other):
13020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13021 
 
13022 
  def __ne__(self, other):
13023 
    return not (self == other)
13024 
 
13025 
class getAllBanners_result:
13026 
  """
13027 
  Attributes:
13028 
   - success
13029 
  """
13030 
 
13031 
  thrift_spec = (
8579 kshitij.so 13032 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13033 
  )
13034 
 
13035 
  def __init__(self, success=None,):
13036 
    self.success = success
13037 
 
13038 
  def read(self, iprot):
13039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13041 
      return
13042 
    iprot.readStructBegin()
13043 
    while True:
13044 
      (fname, ftype, fid) = iprot.readFieldBegin()
13045 
      if ftype == TType.STOP:
13046 
        break
13047 
      if fid == 0:
13048 
        if ftype == TType.LIST:
13049 
          self.success = []
8590 kshitij.so 13050 
          (_etype198, _size195) = iprot.readListBegin()
13051 
          for _i199 in xrange(_size195):
13052 
            _elem200 = Banner()
13053 
            _elem200.read(iprot)
13054 
            self.success.append(_elem200)
6850 kshitij.so 13055 
          iprot.readListEnd()
13056 
        else:
13057 
          iprot.skip(ftype)
13058 
      else:
13059 
        iprot.skip(ftype)
13060 
      iprot.readFieldEnd()
13061 
    iprot.readStructEnd()
13062 
 
13063 
  def write(self, oprot):
13064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13066 
      return
13067 
    oprot.writeStructBegin('getAllBanners_result')
13068 
    if self.success is not None:
13069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13070 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13071 
      for iter201 in self.success:
13072 
        iter201.write(oprot)
6850 kshitij.so 13073 
      oprot.writeListEnd()
13074 
      oprot.writeFieldEnd()
13075 
    oprot.writeFieldStop()
13076 
    oprot.writeStructEnd()
13077 
 
13078 
  def validate(self):
13079 
    return
13080 
 
13081 
 
13082 
  def __repr__(self):
13083 
    L = ['%s=%r' % (key, value)
13084 
      for key, value in self.__dict__.iteritems()]
13085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13086 
 
13087 
  def __eq__(self, other):
13088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13089 
 
13090 
  def __ne__(self, other):
13091 
    return not (self == other)
13092 
 
13093 
class deleteBanner_args:
13094 
  """
13095 
  Attributes:
13096 
   - bannerName
9155 kshitij.so 13097 
   - bannerType
6850 kshitij.so 13098 
  """
13099 
 
13100 
  thrift_spec = (
13101 
    None, # 0
13102 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13103 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13104 
  )
13105 
 
9155 kshitij.so 13106 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13107 
    self.bannerName = bannerName
9155 kshitij.so 13108 
    self.bannerType = bannerType
6850 kshitij.so 13109 
 
13110 
  def read(self, iprot):
13111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13113 
      return
13114 
    iprot.readStructBegin()
13115 
    while True:
13116 
      (fname, ftype, fid) = iprot.readFieldBegin()
13117 
      if ftype == TType.STOP:
13118 
        break
13119 
      if fid == 1:
13120 
        if ftype == TType.STRING:
13121 
          self.bannerName = iprot.readString();
13122 
        else:
13123 
          iprot.skip(ftype)
9155 kshitij.so 13124 
      elif fid == 2:
13125 
        if ftype == TType.I32:
13126 
          self.bannerType = iprot.readI32();
13127 
        else:
13128 
          iprot.skip(ftype)
6850 kshitij.so 13129 
      else:
13130 
        iprot.skip(ftype)
13131 
      iprot.readFieldEnd()
13132 
    iprot.readStructEnd()
13133 
 
13134 
  def write(self, oprot):
13135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13137 
      return
13138 
    oprot.writeStructBegin('deleteBanner_args')
13139 
    if self.bannerName is not None:
13140 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13141 
      oprot.writeString(self.bannerName)
13142 
      oprot.writeFieldEnd()
9155 kshitij.so 13143 
    if self.bannerType is not None:
13144 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13145 
      oprot.writeI32(self.bannerType)
13146 
      oprot.writeFieldEnd()
6850 kshitij.so 13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
13165 
class deleteBanner_result:
13166 
  """
13167 
  Attributes:
13168 
   - success
13169 
  """
13170 
 
13171 
  thrift_spec = (
13172 
    (0, TType.BOOL, 'success', None, None, ), # 0
13173 
  )
13174 
 
13175 
  def __init__(self, success=None,):
13176 
    self.success = success
13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 0:
13188 
        if ftype == TType.BOOL:
13189 
          self.success = iprot.readBool();
13190 
        else:
13191 
          iprot.skip(ftype)
13192 
      else:
13193 
        iprot.skip(ftype)
13194 
      iprot.readFieldEnd()
13195 
    iprot.readStructEnd()
13196 
 
13197 
  def write(self, oprot):
13198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13200 
      return
13201 
    oprot.writeStructBegin('deleteBanner_result')
13202 
    if self.success is not None:
13203 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13204 
      oprot.writeBool(self.success)
13205 
      oprot.writeFieldEnd()
13206 
    oprot.writeFieldStop()
13207 
    oprot.writeStructEnd()
13208 
 
13209 
  def validate(self):
13210 
    return
13211 
 
13212 
 
13213 
  def __repr__(self):
13214 
    L = ['%s=%r' % (key, value)
13215 
      for key, value in self.__dict__.iteritems()]
13216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13217 
 
13218 
  def __eq__(self, other):
13219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13220 
 
13221 
  def __ne__(self, other):
13222 
    return not (self == other)
13223 
 
13224 
class getBannerDetails_args:
13225 
  """
13226 
  Attributes:
13227 
   - bannerName
9155 kshitij.so 13228 
   - bannerType
6850 kshitij.so 13229 
  """
13230 
 
13231 
  thrift_spec = (
13232 
    None, # 0
13233 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13234 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13235 
  )
13236 
 
9155 kshitij.so 13237 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13238 
    self.bannerName = bannerName
9155 kshitij.so 13239 
    self.bannerType = bannerType
6850 kshitij.so 13240 
 
13241 
  def read(self, iprot):
13242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13244 
      return
13245 
    iprot.readStructBegin()
13246 
    while True:
13247 
      (fname, ftype, fid) = iprot.readFieldBegin()
13248 
      if ftype == TType.STOP:
13249 
        break
13250 
      if fid == 1:
13251 
        if ftype == TType.STRING:
13252 
          self.bannerName = iprot.readString();
13253 
        else:
13254 
          iprot.skip(ftype)
9155 kshitij.so 13255 
      elif fid == 2:
13256 
        if ftype == TType.I32:
13257 
          self.bannerType = iprot.readI32();
13258 
        else:
13259 
          iprot.skip(ftype)
6850 kshitij.so 13260 
      else:
13261 
        iprot.skip(ftype)
13262 
      iprot.readFieldEnd()
13263 
    iprot.readStructEnd()
13264 
 
13265 
  def write(self, oprot):
13266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13268 
      return
13269 
    oprot.writeStructBegin('getBannerDetails_args')
13270 
    if self.bannerName is not None:
13271 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13272 
      oprot.writeString(self.bannerName)
13273 
      oprot.writeFieldEnd()
9155 kshitij.so 13274 
    if self.bannerType is not None:
13275 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13276 
      oprot.writeI32(self.bannerType)
13277 
      oprot.writeFieldEnd()
6850 kshitij.so 13278 
    oprot.writeFieldStop()
13279 
    oprot.writeStructEnd()
13280 
 
13281 
  def validate(self):
13282 
    return
13283 
 
13284 
 
13285 
  def __repr__(self):
13286 
    L = ['%s=%r' % (key, value)
13287 
      for key, value in self.__dict__.iteritems()]
13288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13289 
 
13290 
  def __eq__(self, other):
13291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13292 
 
13293 
  def __ne__(self, other):
13294 
    return not (self == other)
13295 
 
13296 
class getBannerDetails_result:
13297 
  """
13298 
  Attributes:
13299 
   - success
13300 
  """
13301 
 
13302 
  thrift_spec = (
13303 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13304 
  )
13305 
 
13306 
  def __init__(self, success=None,):
13307 
    self.success = success
13308 
 
13309 
  def read(self, iprot):
13310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13312 
      return
13313 
    iprot.readStructBegin()
13314 
    while True:
13315 
      (fname, ftype, fid) = iprot.readFieldBegin()
13316 
      if ftype == TType.STOP:
13317 
        break
13318 
      if fid == 0:
13319 
        if ftype == TType.STRUCT:
13320 
          self.success = Banner()
13321 
          self.success.read(iprot)
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
13333 
    oprot.writeStructBegin('getBannerDetails_result')
13334 
    if self.success is not None:
13335 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13336 
      self.success.write(oprot)
13337 
      oprot.writeFieldEnd()
13338 
    oprot.writeFieldStop()
13339 
    oprot.writeStructEnd()
13340 
 
13341 
  def validate(self):
13342 
    return
13343 
 
13344 
 
13345 
  def __repr__(self):
13346 
    L = ['%s=%r' % (key, value)
13347 
      for key, value in self.__dict__.iteritems()]
13348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13349 
 
13350 
  def __eq__(self, other):
13351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13352 
 
13353 
  def __ne__(self, other):
13354 
    return not (self == other)
13355 
 
13356 
class getActiveBanners_args:
13357 
 
13358 
  thrift_spec = (
13359 
  )
13360 
 
13361 
  def read(self, iprot):
13362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13364 
      return
13365 
    iprot.readStructBegin()
13366 
    while True:
13367 
      (fname, ftype, fid) = iprot.readFieldBegin()
13368 
      if ftype == TType.STOP:
13369 
        break
13370 
      else:
13371 
        iprot.skip(ftype)
13372 
      iprot.readFieldEnd()
13373 
    iprot.readStructEnd()
13374 
 
13375 
  def write(self, oprot):
13376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13378 
      return
13379 
    oprot.writeStructBegin('getActiveBanners_args')
13380 
    oprot.writeFieldStop()
13381 
    oprot.writeStructEnd()
13382 
 
13383 
  def validate(self):
13384 
    return
13385 
 
13386 
 
13387 
  def __repr__(self):
13388 
    L = ['%s=%r' % (key, value)
13389 
      for key, value in self.__dict__.iteritems()]
13390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13391 
 
13392 
  def __eq__(self, other):
13393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13394 
 
13395 
  def __ne__(self, other):
13396 
    return not (self == other)
13397 
 
13398 
class getActiveBanners_result:
13399 
  """
13400 
  Attributes:
13401 
   - success
13402 
  """
13403 
 
13404 
  thrift_spec = (
8579 kshitij.so 13405 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13406 
  )
13407 
 
13408 
  def __init__(self, success=None,):
13409 
    self.success = success
13410 
 
13411 
  def read(self, iprot):
13412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13414 
      return
13415 
    iprot.readStructBegin()
13416 
    while True:
13417 
      (fname, ftype, fid) = iprot.readFieldBegin()
13418 
      if ftype == TType.STOP:
13419 
        break
13420 
      if fid == 0:
8579 kshitij.so 13421 
        if ftype == TType.MAP:
13422 
          self.success = {}
8590 kshitij.so 13423 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13424 
          for _i206 in xrange(_size202):
13425 
            _key207 = iprot.readString();
13426 
            _val208 = []
13427 
            (_etype212, _size209) = iprot.readListBegin()
13428 
            for _i213 in xrange(_size209):
13429 
              _elem214 = Banner()
13430 
              _elem214.read(iprot)
13431 
              _val208.append(_elem214)
8579 kshitij.so 13432 
            iprot.readListEnd()
8590 kshitij.so 13433 
            self.success[_key207] = _val208
8579 kshitij.so 13434 
          iprot.readMapEnd()
6850 kshitij.so 13435 
        else:
13436 
          iprot.skip(ftype)
13437 
      else:
13438 
        iprot.skip(ftype)
13439 
      iprot.readFieldEnd()
13440 
    iprot.readStructEnd()
13441 
 
13442 
  def write(self, oprot):
13443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13445 
      return
13446 
    oprot.writeStructBegin('getActiveBanners_result')
13447 
    if self.success is not None:
8579 kshitij.so 13448 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13449 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13450 
      for kiter215,viter216 in self.success.items():
13451 
        oprot.writeString(kiter215)
13452 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13453 
        for iter217 in viter216:
13454 
          iter217.write(oprot)
8579 kshitij.so 13455 
        oprot.writeListEnd()
13456 
      oprot.writeMapEnd()
6850 kshitij.so 13457 
      oprot.writeFieldEnd()
13458 
    oprot.writeFieldStop()
13459 
    oprot.writeStructEnd()
13460 
 
13461 
  def validate(self):
13462 
    return
13463 
 
13464 
 
13465 
  def __repr__(self):
13466 
    L = ['%s=%r' % (key, value)
13467 
      for key, value in self.__dict__.iteritems()]
13468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13469 
 
13470 
  def __eq__(self, other):
13471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13472 
 
13473 
  def __ne__(self, other):
13474 
    return not (self == other)
13475 
 
6849 kshitij.so 13476 
class addBannerMap_args:
13477 
  """
13478 
  Attributes:
8579 kshitij.so 13479 
   - bannerMaps
6849 kshitij.so 13480 
  """
13481 
 
13482 
  thrift_spec = (
13483 
    None, # 0
8579 kshitij.so 13484 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13485 
  )
13486 
 
8579 kshitij.so 13487 
  def __init__(self, bannerMaps=None,):
13488 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13489 
 
13490 
  def read(self, iprot):
13491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13493 
      return
13494 
    iprot.readStructBegin()
13495 
    while True:
13496 
      (fname, ftype, fid) = iprot.readFieldBegin()
13497 
      if ftype == TType.STOP:
13498 
        break
13499 
      if fid == 1:
8579 kshitij.so 13500 
        if ftype == TType.LIST:
13501 
          self.bannerMaps = []
8590 kshitij.so 13502 
          (_etype221, _size218) = iprot.readListBegin()
13503 
          for _i222 in xrange(_size218):
13504 
            _elem223 = BannerMap()
13505 
            _elem223.read(iprot)
13506 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13507 
          iprot.readListEnd()
6849 kshitij.so 13508 
        else:
13509 
          iprot.skip(ftype)
8579 kshitij.so 13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('addBannerMap_args')
13520 
    if self.bannerMaps is not None:
13521 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13522 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13523 
      for iter224 in self.bannerMaps:
13524 
        iter224.write(oprot)
8579 kshitij.so 13525 
      oprot.writeListEnd()
13526 
      oprot.writeFieldEnd()
13527 
    oprot.writeFieldStop()
13528 
    oprot.writeStructEnd()
13529 
 
13530 
  def validate(self):
13531 
    return
13532 
 
13533 
 
13534 
  def __repr__(self):
13535 
    L = ['%s=%r' % (key, value)
13536 
      for key, value in self.__dict__.iteritems()]
13537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13538 
 
13539 
  def __eq__(self, other):
13540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13541 
 
13542 
  def __ne__(self, other):
13543 
    return not (self == other)
13544 
 
13545 
class addBannerMap_result:
13546 
  """
13547 
  Attributes:
13548 
   - success
13549 
  """
13550 
 
13551 
  thrift_spec = (
13552 
    (0, TType.BOOL, 'success', None, None, ), # 0
13553 
  )
13554 
 
13555 
  def __init__(self, success=None,):
13556 
    self.success = success
13557 
 
13558 
  def read(self, iprot):
13559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13561 
      return
13562 
    iprot.readStructBegin()
13563 
    while True:
13564 
      (fname, ftype, fid) = iprot.readFieldBegin()
13565 
      if ftype == TType.STOP:
13566 
        break
13567 
      if fid == 0:
13568 
        if ftype == TType.BOOL:
13569 
          self.success = iprot.readBool();
6849 kshitij.so 13570 
        else:
13571 
          iprot.skip(ftype)
8579 kshitij.so 13572 
      else:
13573 
        iprot.skip(ftype)
13574 
      iprot.readFieldEnd()
13575 
    iprot.readStructEnd()
13576 
 
13577 
  def write(self, oprot):
13578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13580 
      return
13581 
    oprot.writeStructBegin('addBannerMap_result')
13582 
    if self.success is not None:
13583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13584 
      oprot.writeBool(self.success)
13585 
      oprot.writeFieldEnd()
13586 
    oprot.writeFieldStop()
13587 
    oprot.writeStructEnd()
13588 
 
13589 
  def validate(self):
13590 
    return
13591 
 
13592 
 
13593 
  def __repr__(self):
13594 
    L = ['%s=%r' % (key, value)
13595 
      for key, value in self.__dict__.iteritems()]
13596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13597 
 
13598 
  def __eq__(self, other):
13599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13600 
 
13601 
  def __ne__(self, other):
13602 
    return not (self == other)
13603 
 
13604 
class updateBannerMap_args:
13605 
  """
13606 
  Attributes:
13607 
   - bannerMap
13608 
  """
13609 
 
13610 
  thrift_spec = (
13611 
    None, # 0
13612 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13613 
  )
13614 
 
13615 
  def __init__(self, bannerMap=None,):
13616 
    self.bannerMap = bannerMap
13617 
 
13618 
  def read(self, iprot):
13619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13621 
      return
13622 
    iprot.readStructBegin()
13623 
    while True:
13624 
      (fname, ftype, fid) = iprot.readFieldBegin()
13625 
      if ftype == TType.STOP:
13626 
        break
13627 
      if fid == 1:
13628 
        if ftype == TType.STRUCT:
13629 
          self.bannerMap = BannerMap()
13630 
          self.bannerMap.read(iprot)
6849 kshitij.so 13631 
        else:
13632 
          iprot.skip(ftype)
13633 
      else:
13634 
        iprot.skip(ftype)
13635 
      iprot.readFieldEnd()
13636 
    iprot.readStructEnd()
13637 
 
13638 
  def write(self, oprot):
13639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13641 
      return
8579 kshitij.so 13642 
    oprot.writeStructBegin('updateBannerMap_args')
13643 
    if self.bannerMap is not None:
13644 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13645 
      self.bannerMap.write(oprot)
6849 kshitij.so 13646 
      oprot.writeFieldEnd()
13647 
    oprot.writeFieldStop()
13648 
    oprot.writeStructEnd()
13649 
 
13650 
  def validate(self):
13651 
    return
13652 
 
13653 
 
13654 
  def __repr__(self):
13655 
    L = ['%s=%r' % (key, value)
13656 
      for key, value in self.__dict__.iteritems()]
13657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13658 
 
13659 
  def __eq__(self, other):
13660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13661 
 
13662 
  def __ne__(self, other):
13663 
    return not (self == other)
13664 
 
8579 kshitij.so 13665 
class updateBannerMap_result:
6849 kshitij.so 13666 
  """
13667 
  Attributes:
13668 
   - success
13669 
  """
13670 
 
13671 
  thrift_spec = (
13672 
    (0, TType.BOOL, 'success', None, None, ), # 0
13673 
  )
13674 
 
13675 
  def __init__(self, success=None,):
13676 
    self.success = success
13677 
 
13678 
  def read(self, iprot):
13679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13681 
      return
13682 
    iprot.readStructBegin()
13683 
    while True:
13684 
      (fname, ftype, fid) = iprot.readFieldBegin()
13685 
      if ftype == TType.STOP:
13686 
        break
13687 
      if fid == 0:
13688 
        if ftype == TType.BOOL:
13689 
          self.success = iprot.readBool();
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      else:
13693 
        iprot.skip(ftype)
13694 
      iprot.readFieldEnd()
13695 
    iprot.readStructEnd()
13696 
 
13697 
  def write(self, oprot):
13698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13700 
      return
8579 kshitij.so 13701 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13702 
    if self.success is not None:
13703 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13704 
      oprot.writeBool(self.success)
13705 
      oprot.writeFieldEnd()
13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
13724 
class deleteBannerMap_args:
13725 
  """
13726 
  Attributes:
13727 
   - bannerName
13728 
  """
13729 
 
13730 
  thrift_spec = (
13731 
    None, # 0
13732 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13733 
  )
13734 
 
13735 
  def __init__(self, bannerName=None,):
13736 
    self.bannerName = bannerName
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 1:
13748 
        if ftype == TType.STRING:
13749 
          self.bannerName = iprot.readString();
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      else:
13753 
        iprot.skip(ftype)
13754 
      iprot.readFieldEnd()
13755 
    iprot.readStructEnd()
13756 
 
13757 
  def write(self, oprot):
13758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13760 
      return
13761 
    oprot.writeStructBegin('deleteBannerMap_args')
13762 
    if self.bannerName is not None:
13763 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13764 
      oprot.writeString(self.bannerName)
13765 
      oprot.writeFieldEnd()
13766 
    oprot.writeFieldStop()
13767 
    oprot.writeStructEnd()
13768 
 
13769 
  def validate(self):
13770 
    return
13771 
 
13772 
 
13773 
  def __repr__(self):
13774 
    L = ['%s=%r' % (key, value)
13775 
      for key, value in self.__dict__.iteritems()]
13776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13777 
 
13778 
  def __eq__(self, other):
13779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13780 
 
13781 
  def __ne__(self, other):
13782 
    return not (self == other)
13783 
 
13784 
class deleteBannerMap_result:
13785 
  """
13786 
  Attributes:
13787 
   - success
13788 
  """
13789 
 
13790 
  thrift_spec = (
13791 
    (0, TType.BOOL, 'success', None, None, ), # 0
13792 
  )
13793 
 
13794 
  def __init__(self, success=None,):
13795 
    self.success = success
13796 
 
13797 
  def read(self, iprot):
13798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13800 
      return
13801 
    iprot.readStructBegin()
13802 
    while True:
13803 
      (fname, ftype, fid) = iprot.readFieldBegin()
13804 
      if ftype == TType.STOP:
13805 
        break
13806 
      if fid == 0:
13807 
        if ftype == TType.BOOL:
13808 
          self.success = iprot.readBool();
13809 
        else:
13810 
          iprot.skip(ftype)
13811 
      else:
13812 
        iprot.skip(ftype)
13813 
      iprot.readFieldEnd()
13814 
    iprot.readStructEnd()
13815 
 
13816 
  def write(self, oprot):
13817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13819 
      return
13820 
    oprot.writeStructBegin('deleteBannerMap_result')
13821 
    if self.success is not None:
13822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13823 
      oprot.writeBool(self.success)
13824 
      oprot.writeFieldEnd()
13825 
    oprot.writeFieldStop()
13826 
    oprot.writeStructEnd()
13827 
 
13828 
  def validate(self):
13829 
    return
13830 
 
13831 
 
13832 
  def __repr__(self):
13833 
    L = ['%s=%r' % (key, value)
13834 
      for key, value in self.__dict__.iteritems()]
13835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13836 
 
13837 
  def __eq__(self, other):
13838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13839 
 
13840 
  def __ne__(self, other):
13841 
    return not (self == other)
13842 
 
13843 
class getBannerMapDetails_args:
13844 
  """
13845 
  Attributes:
13846 
   - bannerName
9155 kshitij.so 13847 
   - bannerType
6849 kshitij.so 13848 
  """
13849 
 
13850 
  thrift_spec = (
13851 
    None, # 0
13852 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13853 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13854 
  )
13855 
 
9155 kshitij.so 13856 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13857 
    self.bannerName = bannerName
9155 kshitij.so 13858 
    self.bannerType = bannerType
6849 kshitij.so 13859 
 
13860 
  def read(self, iprot):
13861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13863 
      return
13864 
    iprot.readStructBegin()
13865 
    while True:
13866 
      (fname, ftype, fid) = iprot.readFieldBegin()
13867 
      if ftype == TType.STOP:
13868 
        break
13869 
      if fid == 1:
13870 
        if ftype == TType.STRING:
13871 
          self.bannerName = iprot.readString();
13872 
        else:
13873 
          iprot.skip(ftype)
9155 kshitij.so 13874 
      elif fid == 2:
13875 
        if ftype == TType.I32:
13876 
          self.bannerType = iprot.readI32();
13877 
        else:
13878 
          iprot.skip(ftype)
6849 kshitij.so 13879 
      else:
13880 
        iprot.skip(ftype)
13881 
      iprot.readFieldEnd()
13882 
    iprot.readStructEnd()
13883 
 
13884 
  def write(self, oprot):
13885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13887 
      return
13888 
    oprot.writeStructBegin('getBannerMapDetails_args')
13889 
    if self.bannerName is not None:
13890 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13891 
      oprot.writeString(self.bannerName)
13892 
      oprot.writeFieldEnd()
9155 kshitij.so 13893 
    if self.bannerType is not None:
13894 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13895 
      oprot.writeI32(self.bannerType)
13896 
      oprot.writeFieldEnd()
6849 kshitij.so 13897 
    oprot.writeFieldStop()
13898 
    oprot.writeStructEnd()
13899 
 
13900 
  def validate(self):
13901 
    return
13902 
 
13903 
 
13904 
  def __repr__(self):
13905 
    L = ['%s=%r' % (key, value)
13906 
      for key, value in self.__dict__.iteritems()]
13907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13908 
 
13909 
  def __eq__(self, other):
13910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13911 
 
13912 
  def __ne__(self, other):
13913 
    return not (self == other)
13914 
 
13915 
class getBannerMapDetails_result:
13916 
  """
13917 
  Attributes:
13918 
   - success
13919 
  """
13920 
 
13921 
  thrift_spec = (
13922 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13923 
  )
13924 
 
13925 
  def __init__(self, success=None,):
13926 
    self.success = success
13927 
 
13928 
  def read(self, iprot):
13929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13931 
      return
13932 
    iprot.readStructBegin()
13933 
    while True:
13934 
      (fname, ftype, fid) = iprot.readFieldBegin()
13935 
      if ftype == TType.STOP:
13936 
        break
13937 
      if fid == 0:
13938 
        if ftype == TType.LIST:
13939 
          self.success = []
8590 kshitij.so 13940 
          (_etype228, _size225) = iprot.readListBegin()
13941 
          for _i229 in xrange(_size225):
13942 
            _elem230 = BannerMap()
13943 
            _elem230.read(iprot)
13944 
            self.success.append(_elem230)
6849 kshitij.so 13945 
          iprot.readListEnd()
13946 
        else:
13947 
          iprot.skip(ftype)
13948 
      else:
13949 
        iprot.skip(ftype)
13950 
      iprot.readFieldEnd()
13951 
    iprot.readStructEnd()
13952 
 
13953 
  def write(self, oprot):
13954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13956 
      return
13957 
    oprot.writeStructBegin('getBannerMapDetails_result')
13958 
    if self.success is not None:
13959 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13960 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13961 
      for iter231 in self.success:
13962 
        iter231.write(oprot)
6849 kshitij.so 13963 
      oprot.writeListEnd()
13964 
      oprot.writeFieldEnd()
13965 
    oprot.writeFieldStop()
13966 
    oprot.writeStructEnd()
13967 
 
13968 
  def validate(self):
13969 
    return
13970 
 
13971 
 
13972 
  def __repr__(self):
13973 
    L = ['%s=%r' % (key, value)
13974 
      for key, value in self.__dict__.iteritems()]
13975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13976 
 
13977 
  def __eq__(self, other):
13978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13979 
 
13980 
  def __ne__(self, other):
13981 
    return not (self == other)
13982 
 
8579 kshitij.so 13983 
class addBannerUri_args:
13984 
  """
13985 
  Attributes:
13986 
   - bannerUriMappings
13987 
  """
13988 
 
13989 
  thrift_spec = (
13990 
    None, # 0
13991 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13992 
  )
13993 
 
13994 
  def __init__(self, bannerUriMappings=None,):
13995 
    self.bannerUriMappings = bannerUriMappings
13996 
 
13997 
  def read(self, iprot):
13998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14000 
      return
14001 
    iprot.readStructBegin()
14002 
    while True:
14003 
      (fname, ftype, fid) = iprot.readFieldBegin()
14004 
      if ftype == TType.STOP:
14005 
        break
14006 
      if fid == 1:
14007 
        if ftype == TType.LIST:
14008 
          self.bannerUriMappings = []
8590 kshitij.so 14009 
          (_etype235, _size232) = iprot.readListBegin()
14010 
          for _i236 in xrange(_size232):
14011 
            _elem237 = BannerUriMapping()
14012 
            _elem237.read(iprot)
14013 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14014 
          iprot.readListEnd()
14015 
        else:
14016 
          iprot.skip(ftype)
14017 
      else:
14018 
        iprot.skip(ftype)
14019 
      iprot.readFieldEnd()
14020 
    iprot.readStructEnd()
14021 
 
14022 
  def write(self, oprot):
14023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14025 
      return
14026 
    oprot.writeStructBegin('addBannerUri_args')
14027 
    if self.bannerUriMappings is not None:
14028 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14029 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14030 
      for iter238 in self.bannerUriMappings:
14031 
        iter238.write(oprot)
8579 kshitij.so 14032 
      oprot.writeListEnd()
14033 
      oprot.writeFieldEnd()
14034 
    oprot.writeFieldStop()
14035 
    oprot.writeStructEnd()
14036 
 
14037 
  def validate(self):
14038 
    return
14039 
 
14040 
 
14041 
  def __repr__(self):
14042 
    L = ['%s=%r' % (key, value)
14043 
      for key, value in self.__dict__.iteritems()]
14044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14045 
 
14046 
  def __eq__(self, other):
14047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14048 
 
14049 
  def __ne__(self, other):
14050 
    return not (self == other)
14051 
 
14052 
class addBannerUri_result:
14053 
 
14054 
  thrift_spec = (
14055 
  )
14056 
 
14057 
  def read(self, iprot):
14058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14060 
      return
14061 
    iprot.readStructBegin()
14062 
    while True:
14063 
      (fname, ftype, fid) = iprot.readFieldBegin()
14064 
      if ftype == TType.STOP:
14065 
        break
14066 
      else:
14067 
        iprot.skip(ftype)
14068 
      iprot.readFieldEnd()
14069 
    iprot.readStructEnd()
14070 
 
14071 
  def write(self, oprot):
14072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14074 
      return
14075 
    oprot.writeStructBegin('addBannerUri_result')
14076 
    oprot.writeFieldStop()
14077 
    oprot.writeStructEnd()
14078 
 
14079 
  def validate(self):
14080 
    return
14081 
 
14082 
 
14083 
  def __repr__(self):
14084 
    L = ['%s=%r' % (key, value)
14085 
      for key, value in self.__dict__.iteritems()]
14086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14087 
 
14088 
  def __eq__(self, other):
14089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14090 
 
14091 
  def __ne__(self, other):
14092 
    return not (self == other)
14093 
 
14094 
class getUriMapping_args:
14095 
  """
14096 
  Attributes:
14097 
   - bannerName
9155 kshitij.so 14098 
   - bannerType
8579 kshitij.so 14099 
  """
14100 
 
14101 
  thrift_spec = (
14102 
    None, # 0
14103 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14104 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14105 
  )
14106 
 
9155 kshitij.so 14107 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14108 
    self.bannerName = bannerName
9155 kshitij.so 14109 
    self.bannerType = bannerType
8579 kshitij.so 14110 
 
14111 
  def read(self, iprot):
14112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14114 
      return
14115 
    iprot.readStructBegin()
14116 
    while True:
14117 
      (fname, ftype, fid) = iprot.readFieldBegin()
14118 
      if ftype == TType.STOP:
14119 
        break
14120 
      if fid == 1:
14121 
        if ftype == TType.STRING:
14122 
          self.bannerName = iprot.readString();
14123 
        else:
14124 
          iprot.skip(ftype)
9155 kshitij.so 14125 
      elif fid == 2:
14126 
        if ftype == TType.I32:
14127 
          self.bannerType = iprot.readI32();
14128 
        else:
14129 
          iprot.skip(ftype)
8579 kshitij.so 14130 
      else:
14131 
        iprot.skip(ftype)
14132 
      iprot.readFieldEnd()
14133 
    iprot.readStructEnd()
14134 
 
14135 
  def write(self, oprot):
14136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14138 
      return
14139 
    oprot.writeStructBegin('getUriMapping_args')
14140 
    if self.bannerName is not None:
14141 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14142 
      oprot.writeString(self.bannerName)
14143 
      oprot.writeFieldEnd()
9155 kshitij.so 14144 
    if self.bannerType is not None:
14145 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14146 
      oprot.writeI32(self.bannerType)
14147 
      oprot.writeFieldEnd()
8579 kshitij.so 14148 
    oprot.writeFieldStop()
14149 
    oprot.writeStructEnd()
14150 
 
14151 
  def validate(self):
14152 
    return
14153 
 
14154 
 
14155 
  def __repr__(self):
14156 
    L = ['%s=%r' % (key, value)
14157 
      for key, value in self.__dict__.iteritems()]
14158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14159 
 
14160 
  def __eq__(self, other):
14161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14162 
 
14163 
  def __ne__(self, other):
14164 
    return not (self == other)
14165 
 
14166 
class getUriMapping_result:
14167 
  """
14168 
  Attributes:
14169 
   - success
14170 
  """
14171 
 
14172 
  thrift_spec = (
14173 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14174 
  )
14175 
 
14176 
  def __init__(self, success=None,):
14177 
    self.success = success
14178 
 
14179 
  def read(self, iprot):
14180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14182 
      return
14183 
    iprot.readStructBegin()
14184 
    while True:
14185 
      (fname, ftype, fid) = iprot.readFieldBegin()
14186 
      if ftype == TType.STOP:
14187 
        break
14188 
      if fid == 0:
14189 
        if ftype == TType.LIST:
14190 
          self.success = []
8590 kshitij.so 14191 
          (_etype242, _size239) = iprot.readListBegin()
14192 
          for _i243 in xrange(_size239):
14193 
            _elem244 = BannerUriMapping()
14194 
            _elem244.read(iprot)
14195 
            self.success.append(_elem244)
8579 kshitij.so 14196 
          iprot.readListEnd()
14197 
        else:
14198 
          iprot.skip(ftype)
14199 
      else:
14200 
        iprot.skip(ftype)
14201 
      iprot.readFieldEnd()
14202 
    iprot.readStructEnd()
14203 
 
14204 
  def write(self, oprot):
14205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14207 
      return
14208 
    oprot.writeStructBegin('getUriMapping_result')
14209 
    if self.success is not None:
14210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14212 
      for iter245 in self.success:
14213 
        iter245.write(oprot)
8579 kshitij.so 14214 
      oprot.writeListEnd()
14215 
      oprot.writeFieldEnd()
14216 
    oprot.writeFieldStop()
14217 
    oprot.writeStructEnd()
14218 
 
14219 
  def validate(self):
14220 
    return
14221 
 
14222 
 
14223 
  def __repr__(self):
14224 
    L = ['%s=%r' % (key, value)
14225 
      for key, value in self.__dict__.iteritems()]
14226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14227 
 
14228 
  def __eq__(self, other):
14229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14230 
 
14231 
  def __ne__(self, other):
14232 
    return not (self == other)
14233 
 
14234 
class addCampaign_args:
14235 
  """
14236 
  Attributes:
14237 
   - campaign
14238 
  """
14239 
 
14240 
  thrift_spec = (
14241 
    None, # 0
14242 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14243 
  )
14244 
 
14245 
  def __init__(self, campaign=None,):
14246 
    self.campaign = campaign
14247 
 
14248 
  def read(self, iprot):
14249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14251 
      return
14252 
    iprot.readStructBegin()
14253 
    while True:
14254 
      (fname, ftype, fid) = iprot.readFieldBegin()
14255 
      if ftype == TType.STOP:
14256 
        break
14257 
      if fid == 1:
14258 
        if ftype == TType.STRUCT:
14259 
          self.campaign = Campaign()
14260 
          self.campaign.read(iprot)
14261 
        else:
14262 
          iprot.skip(ftype)
14263 
      else:
14264 
        iprot.skip(ftype)
14265 
      iprot.readFieldEnd()
14266 
    iprot.readStructEnd()
14267 
 
14268 
  def write(self, oprot):
14269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14271 
      return
14272 
    oprot.writeStructBegin('addCampaign_args')
14273 
    if self.campaign is not None:
14274 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14275 
      self.campaign.write(oprot)
14276 
      oprot.writeFieldEnd()
14277 
    oprot.writeFieldStop()
14278 
    oprot.writeStructEnd()
14279 
 
14280 
  def validate(self):
14281 
    return
14282 
 
14283 
 
14284 
  def __repr__(self):
14285 
    L = ['%s=%r' % (key, value)
14286 
      for key, value in self.__dict__.iteritems()]
14287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14288 
 
14289 
  def __eq__(self, other):
14290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14291 
 
14292 
  def __ne__(self, other):
14293 
    return not (self == other)
14294 
 
14295 
class addCampaign_result:
14296 
 
14297 
  thrift_spec = (
14298 
  )
14299 
 
14300 
  def read(self, iprot):
14301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14303 
      return
14304 
    iprot.readStructBegin()
14305 
    while True:
14306 
      (fname, ftype, fid) = iprot.readFieldBegin()
14307 
      if ftype == TType.STOP:
14308 
        break
14309 
      else:
14310 
        iprot.skip(ftype)
14311 
      iprot.readFieldEnd()
14312 
    iprot.readStructEnd()
14313 
 
14314 
  def write(self, oprot):
14315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14317 
      return
14318 
    oprot.writeStructBegin('addCampaign_result')
14319 
    oprot.writeFieldStop()
14320 
    oprot.writeStructEnd()
14321 
 
14322 
  def validate(self):
14323 
    return
14324 
 
14325 
 
14326 
  def __repr__(self):
14327 
    L = ['%s=%r' % (key, value)
14328 
      for key, value in self.__dict__.iteritems()]
14329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14330 
 
14331 
  def __eq__(self, other):
14332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14333 
 
14334 
  def __ne__(self, other):
14335 
    return not (self == other)
14336 
 
14337 
class getCampaigns_args:
14338 
  """
14339 
  Attributes:
14340 
   - campaignName
14341 
  """
14342 
 
14343 
  thrift_spec = (
14344 
    None, # 0
14345 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14346 
  )
14347 
 
14348 
  def __init__(self, campaignName=None,):
14349 
    self.campaignName = campaignName
14350 
 
14351 
  def read(self, iprot):
14352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14354 
      return
14355 
    iprot.readStructBegin()
14356 
    while True:
14357 
      (fname, ftype, fid) = iprot.readFieldBegin()
14358 
      if ftype == TType.STOP:
14359 
        break
14360 
      if fid == 1:
14361 
        if ftype == TType.STRING:
14362 
          self.campaignName = iprot.readString();
14363 
        else:
14364 
          iprot.skip(ftype)
14365 
      else:
14366 
        iprot.skip(ftype)
14367 
      iprot.readFieldEnd()
14368 
    iprot.readStructEnd()
14369 
 
14370 
  def write(self, oprot):
14371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14373 
      return
14374 
    oprot.writeStructBegin('getCampaigns_args')
14375 
    if self.campaignName is not None:
14376 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14377 
      oprot.writeString(self.campaignName)
14378 
      oprot.writeFieldEnd()
14379 
    oprot.writeFieldStop()
14380 
    oprot.writeStructEnd()
14381 
 
14382 
  def validate(self):
14383 
    return
14384 
 
14385 
 
14386 
  def __repr__(self):
14387 
    L = ['%s=%r' % (key, value)
14388 
      for key, value in self.__dict__.iteritems()]
14389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14390 
 
14391 
  def __eq__(self, other):
14392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14393 
 
14394 
  def __ne__(self, other):
14395 
    return not (self == other)
14396 
 
14397 
class getCampaigns_result:
14398 
  """
14399 
  Attributes:
14400 
   - success
14401 
  """
14402 
 
14403 
  thrift_spec = (
14404 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14405 
  )
14406 
 
14407 
  def __init__(self, success=None,):
14408 
    self.success = success
14409 
 
14410 
  def read(self, iprot):
14411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14413 
      return
14414 
    iprot.readStructBegin()
14415 
    while True:
14416 
      (fname, ftype, fid) = iprot.readFieldBegin()
14417 
      if ftype == TType.STOP:
14418 
        break
14419 
      if fid == 0:
14420 
        if ftype == TType.LIST:
14421 
          self.success = []
8590 kshitij.so 14422 
          (_etype249, _size246) = iprot.readListBegin()
14423 
          for _i250 in xrange(_size246):
14424 
            _elem251 = Campaign()
14425 
            _elem251.read(iprot)
14426 
            self.success.append(_elem251)
8579 kshitij.so 14427 
          iprot.readListEnd()
14428 
        else:
14429 
          iprot.skip(ftype)
14430 
      else:
14431 
        iprot.skip(ftype)
14432 
      iprot.readFieldEnd()
14433 
    iprot.readStructEnd()
14434 
 
14435 
  def write(self, oprot):
14436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14438 
      return
14439 
    oprot.writeStructBegin('getCampaigns_result')
14440 
    if self.success is not None:
14441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14443 
      for iter252 in self.success:
14444 
        iter252.write(oprot)
8579 kshitij.so 14445 
      oprot.writeListEnd()
14446 
      oprot.writeFieldEnd()
14447 
    oprot.writeFieldStop()
14448 
    oprot.writeStructEnd()
14449 
 
14450 
  def validate(self):
14451 
    return
14452 
 
14453 
 
14454 
  def __repr__(self):
14455 
    L = ['%s=%r' % (key, value)
14456 
      for key, value in self.__dict__.iteritems()]
14457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14458 
 
14459 
  def __eq__(self, other):
14460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14461 
 
14462 
  def __ne__(self, other):
14463 
    return not (self == other)
14464 
 
14465 
class deleteCampaign_args:
14466 
  """
14467 
  Attributes:
14468 
   - campaignId
14469 
  """
14470 
 
14471 
  thrift_spec = (
14472 
    None, # 0
14473 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14474 
  )
14475 
 
14476 
  def __init__(self, campaignId=None,):
14477 
    self.campaignId = campaignId
14478 
 
14479 
  def read(self, iprot):
14480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14482 
      return
14483 
    iprot.readStructBegin()
14484 
    while True:
14485 
      (fname, ftype, fid) = iprot.readFieldBegin()
14486 
      if ftype == TType.STOP:
14487 
        break
14488 
      if fid == 1:
14489 
        if ftype == TType.I64:
14490 
          self.campaignId = iprot.readI64();
14491 
        else:
14492 
          iprot.skip(ftype)
14493 
      else:
14494 
        iprot.skip(ftype)
14495 
      iprot.readFieldEnd()
14496 
    iprot.readStructEnd()
14497 
 
14498 
  def write(self, oprot):
14499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14501 
      return
14502 
    oprot.writeStructBegin('deleteCampaign_args')
14503 
    if self.campaignId is not None:
14504 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14505 
      oprot.writeI64(self.campaignId)
14506 
      oprot.writeFieldEnd()
14507 
    oprot.writeFieldStop()
14508 
    oprot.writeStructEnd()
14509 
 
14510 
  def validate(self):
14511 
    return
14512 
 
14513 
 
14514 
  def __repr__(self):
14515 
    L = ['%s=%r' % (key, value)
14516 
      for key, value in self.__dict__.iteritems()]
14517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14518 
 
14519 
  def __eq__(self, other):
14520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14521 
 
14522 
  def __ne__(self, other):
14523 
    return not (self == other)
14524 
 
14525 
class deleteCampaign_result:
14526 
 
14527 
  thrift_spec = (
14528 
  )
14529 
 
14530 
  def read(self, iprot):
14531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14533 
      return
14534 
    iprot.readStructBegin()
14535 
    while True:
14536 
      (fname, ftype, fid) = iprot.readFieldBegin()
14537 
      if ftype == TType.STOP:
14538 
        break
14539 
      else:
14540 
        iprot.skip(ftype)
14541 
      iprot.readFieldEnd()
14542 
    iprot.readStructEnd()
14543 
 
14544 
  def write(self, oprot):
14545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14547 
      return
14548 
    oprot.writeStructBegin('deleteCampaign_result')
14549 
    oprot.writeFieldStop()
14550 
    oprot.writeStructEnd()
14551 
 
14552 
  def validate(self):
14553 
    return
14554 
 
14555 
 
14556 
  def __repr__(self):
14557 
    L = ['%s=%r' % (key, value)
14558 
      for key, value in self.__dict__.iteritems()]
14559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14560 
 
14561 
  def __eq__(self, other):
14562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14563 
 
14564 
  def __ne__(self, other):
14565 
    return not (self == other)
14566 
 
14567 
class getAllCampaigns_args:
14568 
 
14569 
  thrift_spec = (
14570 
  )
14571 
 
14572 
  def read(self, iprot):
14573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14575 
      return
14576 
    iprot.readStructBegin()
14577 
    while True:
14578 
      (fname, ftype, fid) = iprot.readFieldBegin()
14579 
      if ftype == TType.STOP:
14580 
        break
14581 
      else:
14582 
        iprot.skip(ftype)
14583 
      iprot.readFieldEnd()
14584 
    iprot.readStructEnd()
14585 
 
14586 
  def write(self, oprot):
14587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14589 
      return
14590 
    oprot.writeStructBegin('getAllCampaigns_args')
14591 
    oprot.writeFieldStop()
14592 
    oprot.writeStructEnd()
14593 
 
14594 
  def validate(self):
14595 
    return
14596 
 
14597 
 
14598 
  def __repr__(self):
14599 
    L = ['%s=%r' % (key, value)
14600 
      for key, value in self.__dict__.iteritems()]
14601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14602 
 
14603 
  def __eq__(self, other):
14604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14605 
 
14606 
  def __ne__(self, other):
14607 
    return not (self == other)
14608 
 
14609 
class getAllCampaigns_result:
14610 
  """
14611 
  Attributes:
14612 
   - success
14613 
  """
14614 
 
14615 
  thrift_spec = (
14616 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14617 
  )
14618 
 
14619 
  def __init__(self, success=None,):
14620 
    self.success = success
14621 
 
14622 
  def read(self, iprot):
14623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14625 
      return
14626 
    iprot.readStructBegin()
14627 
    while True:
14628 
      (fname, ftype, fid) = iprot.readFieldBegin()
14629 
      if ftype == TType.STOP:
14630 
        break
14631 
      if fid == 0:
14632 
        if ftype == TType.LIST:
14633 
          self.success = []
8590 kshitij.so 14634 
          (_etype256, _size253) = iprot.readListBegin()
14635 
          for _i257 in xrange(_size253):
14636 
            _elem258 = iprot.readString();
14637 
            self.success.append(_elem258)
8579 kshitij.so 14638 
          iprot.readListEnd()
14639 
        else:
14640 
          iprot.skip(ftype)
14641 
      else:
14642 
        iprot.skip(ftype)
14643 
      iprot.readFieldEnd()
14644 
    iprot.readStructEnd()
14645 
 
14646 
  def write(self, oprot):
14647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14649 
      return
14650 
    oprot.writeStructBegin('getAllCampaigns_result')
14651 
    if self.success is not None:
14652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14653 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14654 
      for iter259 in self.success:
14655 
        oprot.writeString(iter259)
8579 kshitij.so 14656 
      oprot.writeListEnd()
14657 
      oprot.writeFieldEnd()
14658 
    oprot.writeFieldStop()
14659 
    oprot.writeStructEnd()
14660 
 
14661 
  def validate(self):
14662 
    return
14663 
 
14664 
 
14665 
  def __repr__(self):
14666 
    L = ['%s=%r' % (key, value)
14667 
      for key, value in self.__dict__.iteritems()]
14668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14669 
 
14670 
  def __eq__(self, other):
14671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14672 
 
14673 
  def __ne__(self, other):
14674 
    return not (self == other)
14675 
 
9155 kshitij.so 14676 
class getActiveBannersForMobileSite_args:
14677 
 
14678 
  thrift_spec = (
14679 
  )
14680 
 
14681 
  def read(self, iprot):
14682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14684 
      return
14685 
    iprot.readStructBegin()
14686 
    while True:
14687 
      (fname, ftype, fid) = iprot.readFieldBegin()
14688 
      if ftype == TType.STOP:
14689 
        break
14690 
      else:
14691 
        iprot.skip(ftype)
14692 
      iprot.readFieldEnd()
14693 
    iprot.readStructEnd()
14694 
 
14695 
  def write(self, oprot):
14696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14698 
      return
14699 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14700 
    oprot.writeFieldStop()
14701 
    oprot.writeStructEnd()
14702 
 
14703 
  def validate(self):
14704 
    return
14705 
 
14706 
 
14707 
  def __repr__(self):
14708 
    L = ['%s=%r' % (key, value)
14709 
      for key, value in self.__dict__.iteritems()]
14710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14711 
 
14712 
  def __eq__(self, other):
14713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14714 
 
14715 
  def __ne__(self, other):
14716 
    return not (self == other)
14717 
 
14718 
class getActiveBannersForMobileSite_result:
14719 
  """
14720 
  Attributes:
14721 
   - success
14722 
  """
14723 
 
14724 
  thrift_spec = (
14725 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14726 
  )
14727 
 
14728 
  def __init__(self, success=None,):
14729 
    self.success = success
14730 
 
14731 
  def read(self, iprot):
14732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14734 
      return
14735 
    iprot.readStructBegin()
14736 
    while True:
14737 
      (fname, ftype, fid) = iprot.readFieldBegin()
14738 
      if ftype == TType.STOP:
14739 
        break
14740 
      if fid == 0:
14741 
        if ftype == TType.MAP:
14742 
          self.success = {}
14743 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14744 
          for _i264 in xrange(_size260):
14745 
            _key265 = iprot.readString();
14746 
            _val266 = []
14747 
            (_etype270, _size267) = iprot.readListBegin()
14748 
            for _i271 in xrange(_size267):
14749 
              _elem272 = Banner()
14750 
              _elem272.read(iprot)
14751 
              _val266.append(_elem272)
14752 
            iprot.readListEnd()
14753 
            self.success[_key265] = _val266
14754 
          iprot.readMapEnd()
14755 
        else:
14756 
          iprot.skip(ftype)
14757 
      else:
14758 
        iprot.skip(ftype)
14759 
      iprot.readFieldEnd()
14760 
    iprot.readStructEnd()
14761 
 
14762 
  def write(self, oprot):
14763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14765 
      return
14766 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14767 
    if self.success is not None:
14768 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14769 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14770 
      for kiter273,viter274 in self.success.items():
14771 
        oprot.writeString(kiter273)
14772 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14773 
        for iter275 in viter274:
14774 
          iter275.write(oprot)
14775 
        oprot.writeListEnd()
14776 
      oprot.writeMapEnd()
14777 
      oprot.writeFieldEnd()
14778 
    oprot.writeFieldStop()
14779 
    oprot.writeStructEnd()
14780 
 
14781 
  def validate(self):
14782 
    return
14783 
 
14784 
 
14785 
  def __repr__(self):
14786 
    L = ['%s=%r' % (key, value)
14787 
      for key, value in self.__dict__.iteritems()]
14788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14789 
 
14790 
  def __eq__(self, other):
14791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14792 
 
14793 
  def __ne__(self, other):
14794 
    return not (self == other)
14795 
 
5944 mandeep.dh 14796 
class deleteSimilarItem_args:
14797 
  """
14798 
  Attributes:
14799 
   - itemId
14800 
   - catalogItemId
14801 
  """
14802 
 
14803 
  thrift_spec = (
14804 
    None, # 0
14805 
    (1, TType.I64, 'itemId', None, None, ), # 1
14806 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14807 
  )
14808 
 
14809 
  def __init__(self, itemId=None, catalogItemId=None,):
14810 
    self.itemId = itemId
14811 
    self.catalogItemId = catalogItemId
14812 
 
14813 
  def read(self, iprot):
14814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14816 
      return
14817 
    iprot.readStructBegin()
14818 
    while True:
14819 
      (fname, ftype, fid) = iprot.readFieldBegin()
14820 
      if ftype == TType.STOP:
14821 
        break
14822 
      if fid == 1:
14823 
        if ftype == TType.I64:
14824 
          self.itemId = iprot.readI64();
14825 
        else:
14826 
          iprot.skip(ftype)
14827 
      elif fid == 2:
14828 
        if ftype == TType.I64:
14829 
          self.catalogItemId = iprot.readI64();
14830 
        else:
14831 
          iprot.skip(ftype)
14832 
      else:
14833 
        iprot.skip(ftype)
14834 
      iprot.readFieldEnd()
14835 
    iprot.readStructEnd()
14836 
 
14837 
  def write(self, oprot):
14838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14840 
      return
14841 
    oprot.writeStructBegin('deleteSimilarItem_args')
14842 
    if self.itemId is not None:
14843 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14844 
      oprot.writeI64(self.itemId)
14845 
      oprot.writeFieldEnd()
14846 
    if self.catalogItemId is not None:
14847 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14848 
      oprot.writeI64(self.catalogItemId)
14849 
      oprot.writeFieldEnd()
14850 
    oprot.writeFieldStop()
14851 
    oprot.writeStructEnd()
14852 
 
14853 
  def validate(self):
14854 
    return
14855 
 
14856 
 
14857 
  def __repr__(self):
14858 
    L = ['%s=%r' % (key, value)
14859 
      for key, value in self.__dict__.iteritems()]
14860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14861 
 
14862 
  def __eq__(self, other):
14863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14864 
 
14865 
  def __ne__(self, other):
14866 
    return not (self == other)
14867 
 
14868 
class deleteSimilarItem_result:
14869 
  """
14870 
  Attributes:
14871 
   - success
14872 
   - cex
14873 
  """
14874 
 
14875 
  thrift_spec = (
14876 
    (0, TType.BOOL, 'success', None, None, ), # 0
14877 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14878 
  )
14879 
 
14880 
  def __init__(self, success=None, cex=None,):
14881 
    self.success = success
14882 
    self.cex = cex
14883 
 
14884 
  def read(self, iprot):
14885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14887 
      return
14888 
    iprot.readStructBegin()
14889 
    while True:
14890 
      (fname, ftype, fid) = iprot.readFieldBegin()
14891 
      if ftype == TType.STOP:
14892 
        break
14893 
      if fid == 0:
14894 
        if ftype == TType.BOOL:
14895 
          self.success = iprot.readBool();
14896 
        else:
14897 
          iprot.skip(ftype)
14898 
      elif fid == 1:
14899 
        if ftype == TType.STRUCT:
14900 
          self.cex = CatalogServiceException()
14901 
          self.cex.read(iprot)
14902 
        else:
14903 
          iprot.skip(ftype)
14904 
      else:
14905 
        iprot.skip(ftype)
14906 
      iprot.readFieldEnd()
14907 
    iprot.readStructEnd()
14908 
 
14909 
  def write(self, oprot):
14910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14912 
      return
14913 
    oprot.writeStructBegin('deleteSimilarItem_result')
14914 
    if self.success is not None:
14915 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14916 
      oprot.writeBool(self.success)
14917 
      oprot.writeFieldEnd()
14918 
    if self.cex is not None:
14919 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14920 
      self.cex.write(oprot)
14921 
      oprot.writeFieldEnd()
14922 
    oprot.writeFieldStop()
14923 
    oprot.writeStructEnd()
14924 
 
14925 
  def validate(self):
14926 
    return
14927 
 
14928 
 
14929 
  def __repr__(self):
14930 
    L = ['%s=%r' % (key, value)
14931 
      for key, value in self.__dict__.iteritems()]
14932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14933 
 
14934 
  def __eq__(self, other):
14935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14936 
 
14937 
  def __ne__(self, other):
14938 
    return not (self == other)
14939 
 
14940 
class checkSimilarItem_args:
14941 
  """
14942 
  Attributes:
14943 
   - brand
14944 
   - modelNumber
14945 
   - modelName
14946 
   - color
14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    None, # 0
14951 
    (1, TType.STRING, 'brand', None, None, ), # 1
14952 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14953 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14954 
    (4, TType.STRING, 'color', None, None, ), # 4
14955 
  )
14956 
 
14957 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14958 
    self.brand = brand
14959 
    self.modelNumber = modelNumber
14960 
    self.modelName = modelName
14961 
    self.color = color
14962 
 
14963 
  def read(self, iprot):
14964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14966 
      return
14967 
    iprot.readStructBegin()
14968 
    while True:
14969 
      (fname, ftype, fid) = iprot.readFieldBegin()
14970 
      if ftype == TType.STOP:
14971 
        break
14972 
      if fid == 1:
14973 
        if ftype == TType.STRING:
14974 
          self.brand = iprot.readString();
14975 
        else:
14976 
          iprot.skip(ftype)
14977 
      elif fid == 2:
14978 
        if ftype == TType.STRING:
14979 
          self.modelNumber = iprot.readString();
14980 
        else:
14981 
          iprot.skip(ftype)
14982 
      elif fid == 3:
14983 
        if ftype == TType.STRING:
14984 
          self.modelName = iprot.readString();
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      elif fid == 4:
14988 
        if ftype == TType.STRING:
14989 
          self.color = iprot.readString();
14990 
        else:
14991 
          iprot.skip(ftype)
14992 
      else:
14993 
        iprot.skip(ftype)
14994 
      iprot.readFieldEnd()
14995 
    iprot.readStructEnd()
14996 
 
14997 
  def write(self, oprot):
14998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15000 
      return
15001 
    oprot.writeStructBegin('checkSimilarItem_args')
15002 
    if self.brand is not None:
15003 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15004 
      oprot.writeString(self.brand)
15005 
      oprot.writeFieldEnd()
15006 
    if self.modelNumber is not None:
15007 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15008 
      oprot.writeString(self.modelNumber)
15009 
      oprot.writeFieldEnd()
15010 
    if self.modelName is not None:
15011 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15012 
      oprot.writeString(self.modelName)
15013 
      oprot.writeFieldEnd()
15014 
    if self.color is not None:
15015 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15016 
      oprot.writeString(self.color)
15017 
      oprot.writeFieldEnd()
15018 
    oprot.writeFieldStop()
15019 
    oprot.writeStructEnd()
15020 
 
15021 
  def validate(self):
15022 
    return
15023 
 
15024 
 
15025 
  def __repr__(self):
15026 
    L = ['%s=%r' % (key, value)
15027 
      for key, value in self.__dict__.iteritems()]
15028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15029 
 
15030 
  def __eq__(self, other):
15031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15032 
 
15033 
  def __ne__(self, other):
15034 
    return not (self == other)
15035 
 
15036 
class checkSimilarItem_result:
15037 
  """
15038 
  Attributes:
15039 
   - success
15040 
  """
15041 
 
15042 
  thrift_spec = (
15043 
    (0, TType.I64, 'success', None, None, ), # 0
15044 
  )
15045 
 
15046 
  def __init__(self, success=None,):
15047 
    self.success = success
15048 
 
15049 
  def read(self, iprot):
15050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15052 
      return
15053 
    iprot.readStructBegin()
15054 
    while True:
15055 
      (fname, ftype, fid) = iprot.readFieldBegin()
15056 
      if ftype == TType.STOP:
15057 
        break
15058 
      if fid == 0:
15059 
        if ftype == TType.I64:
15060 
          self.success = iprot.readI64();
15061 
        else:
15062 
          iprot.skip(ftype)
15063 
      else:
15064 
        iprot.skip(ftype)
15065 
      iprot.readFieldEnd()
15066 
    iprot.readStructEnd()
15067 
 
15068 
  def write(self, oprot):
15069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15071 
      return
15072 
    oprot.writeStructBegin('checkSimilarItem_result')
15073 
    if self.success is not None:
15074 
      oprot.writeFieldBegin('success', TType.I64, 0)
15075 
      oprot.writeI64(self.success)
15076 
      oprot.writeFieldEnd()
15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
15094 
 
15095 
class validateRiskyStatus_args:
15096 
  """
15097 
  Attributes:
15098 
   - itemId
15099 
  """
15100 
 
15101 
  thrift_spec = (
15102 
    None, # 0
15103 
    (1, TType.I64, 'itemId', None, None, ), # 1
15104 
  )
15105 
 
15106 
  def __init__(self, itemId=None,):
15107 
    self.itemId = itemId
15108 
 
15109 
  def read(self, iprot):
15110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15112 
      return
15113 
    iprot.readStructBegin()
15114 
    while True:
15115 
      (fname, ftype, fid) = iprot.readFieldBegin()
15116 
      if ftype == TType.STOP:
15117 
        break
15118 
      if fid == 1:
15119 
        if ftype == TType.I64:
15120 
          self.itemId = iprot.readI64();
15121 
        else:
15122 
          iprot.skip(ftype)
15123 
      else:
15124 
        iprot.skip(ftype)
15125 
      iprot.readFieldEnd()
15126 
    iprot.readStructEnd()
15127 
 
15128 
  def write(self, oprot):
15129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15131 
      return
15132 
    oprot.writeStructBegin('validateRiskyStatus_args')
15133 
    if self.itemId is not None:
15134 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15135 
      oprot.writeI64(self.itemId)
15136 
      oprot.writeFieldEnd()
15137 
    oprot.writeFieldStop()
15138 
    oprot.writeStructEnd()
15139 
 
15140 
  def validate(self):
15141 
    return
15142 
 
15143 
 
15144 
  def __repr__(self):
15145 
    L = ['%s=%r' % (key, value)
15146 
      for key, value in self.__dict__.iteritems()]
15147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15148 
 
15149 
  def __eq__(self, other):
15150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15151 
 
15152 
  def __ne__(self, other):
15153 
    return not (self == other)
15154 
 
15155 
class validateRiskyStatus_result:
15156 
 
15157 
  thrift_spec = (
15158 
  )
15159 
 
15160 
  def read(self, iprot):
15161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15163 
      return
15164 
    iprot.readStructBegin()
15165 
    while True:
15166 
      (fname, ftype, fid) = iprot.readFieldBegin()
15167 
      if ftype == TType.STOP:
15168 
        break
15169 
      else:
15170 
        iprot.skip(ftype)
15171 
      iprot.readFieldEnd()
15172 
    iprot.readStructEnd()
15173 
 
15174 
  def write(self, oprot):
15175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15177 
      return
15178 
    oprot.writeStructBegin('validateRiskyStatus_result')
15179 
    oprot.writeFieldStop()
15180 
    oprot.writeStructEnd()
15181 
 
15182 
  def validate(self):
15183 
    return
15184 
 
15185 
 
15186 
  def __repr__(self):
15187 
    L = ['%s=%r' % (key, value)
15188 
      for key, value in self.__dict__.iteritems()]
15189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15190 
 
15191 
  def __eq__(self, other):
15192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15193 
 
15194 
  def __ne__(self, other):
15195 
    return not (self == other)
15196 
 
15197 
class changeItemRiskyFlag_args:
15198 
  """
15199 
  Attributes:
15200 
   - itemId
15201 
   - risky
15202 
  """
15203 
 
15204 
  thrift_spec = (
15205 
    None, # 0
15206 
    (1, TType.I64, 'itemId', None, None, ), # 1
15207 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15208 
  )
15209 
 
15210 
  def __init__(self, itemId=None, risky=None,):
15211 
    self.itemId = itemId
15212 
    self.risky = risky
15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == 1:
15224 
        if ftype == TType.I64:
15225 
          self.itemId = iprot.readI64();
15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      elif fid == 2:
15229 
        if ftype == TType.BOOL:
15230 
          self.risky = iprot.readBool();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15243 
    if self.itemId is not None:
15244 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15245 
      oprot.writeI64(self.itemId)
15246 
      oprot.writeFieldEnd()
15247 
    if self.risky is not None:
15248 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15249 
      oprot.writeBool(self.risky)
15250 
      oprot.writeFieldEnd()
15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
15269 
class changeItemRiskyFlag_result:
15270 
 
15271 
  thrift_spec = (
15272 
  )
15273 
 
15274 
  def read(self, iprot):
15275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15277 
      return
15278 
    iprot.readStructBegin()
15279 
    while True:
15280 
      (fname, ftype, fid) = iprot.readFieldBegin()
15281 
      if ftype == TType.STOP:
15282 
        break
15283 
      else:
15284 
        iprot.skip(ftype)
15285 
      iprot.readFieldEnd()
15286 
    iprot.readStructEnd()
15287 
 
15288 
  def write(self, oprot):
15289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15291 
      return
15292 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15293 
    oprot.writeFieldStop()
15294 
    oprot.writeStructEnd()
15295 
 
15296 
  def validate(self):
15297 
    return
15298 
 
15299 
 
15300 
  def __repr__(self):
15301 
    L = ['%s=%r' % (key, value)
15302 
      for key, value in self.__dict__.iteritems()]
15303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15304 
 
15305 
  def __eq__(self, other):
15306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15307 
 
15308 
  def __ne__(self, other):
15309 
    return not (self == other)
15310 
 
15311 
class getItemsByRiskyFlag_args:
15312 
 
15313 
  thrift_spec = (
15314 
  )
15315 
 
15316 
  def read(self, iprot):
15317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15319 
      return
15320 
    iprot.readStructBegin()
15321 
    while True:
15322 
      (fname, ftype, fid) = iprot.readFieldBegin()
15323 
      if ftype == TType.STOP:
15324 
        break
15325 
      else:
15326 
        iprot.skip(ftype)
15327 
      iprot.readFieldEnd()
15328 
    iprot.readStructEnd()
15329 
 
15330 
  def write(self, oprot):
15331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15333 
      return
15334 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15335 
    oprot.writeFieldStop()
15336 
    oprot.writeStructEnd()
15337 
 
15338 
  def validate(self):
15339 
    return
15340 
 
15341 
 
15342 
  def __repr__(self):
15343 
    L = ['%s=%r' % (key, value)
15344 
      for key, value in self.__dict__.iteritems()]
15345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15346 
 
15347 
  def __eq__(self, other):
15348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15349 
 
15350 
  def __ne__(self, other):
15351 
    return not (self == other)
15352 
 
15353 
class getItemsByRiskyFlag_result:
15354 
  """
15355 
  Attributes:
15356 
   - success
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15361 
  )
15362 
 
15363 
  def __init__(self, success=None,):
15364 
    self.success = success
15365 
 
15366 
  def read(self, iprot):
15367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15369 
      return
15370 
    iprot.readStructBegin()
15371 
    while True:
15372 
      (fname, ftype, fid) = iprot.readFieldBegin()
15373 
      if ftype == TType.STOP:
15374 
        break
15375 
      if fid == 0:
15376 
        if ftype == TType.LIST:
15377 
          self.success = []
9155 kshitij.so 15378 
          (_etype279, _size276) = iprot.readListBegin()
15379 
          for _i280 in xrange(_size276):
15380 
            _elem281 = Item()
15381 
            _elem281.read(iprot)
15382 
            self.success.append(_elem281)
5944 mandeep.dh 15383 
          iprot.readListEnd()
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      else:
15387 
        iprot.skip(ftype)
15388 
      iprot.readFieldEnd()
15389 
    iprot.readStructEnd()
15390 
 
15391 
  def write(self, oprot):
15392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15394 
      return
15395 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15396 
    if self.success is not None:
15397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15399 
      for iter282 in self.success:
15400 
        iter282.write(oprot)
5944 mandeep.dh 15401 
      oprot.writeListEnd()
15402 
      oprot.writeFieldEnd()
15403 
    oprot.writeFieldStop()
15404 
    oprot.writeStructEnd()
15405 
 
15406 
  def validate(self):
15407 
    return
15408 
 
15409 
 
15410 
  def __repr__(self):
15411 
    L = ['%s=%r' % (key, value)
15412 
      for key, value in self.__dict__.iteritems()]
15413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15414 
 
15415 
  def __eq__(self, other):
15416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15417 
 
15418 
  def __ne__(self, other):
15419 
    return not (self == other)
15420 
 
15421 
class getItemsForMasterSheet_args:
15422 
  """
15423 
  Attributes:
15424 
   - category
15425 
   - brand
15426 
  """
15427 
 
15428 
  thrift_spec = (
15429 
    None, # 0
15430 
    (1, TType.STRING, 'category', None, None, ), # 1
15431 
    (2, TType.STRING, 'brand', None, None, ), # 2
15432 
  )
15433 
 
15434 
  def __init__(self, category=None, brand=None,):
15435 
    self.category = category
15436 
    self.brand = brand
15437 
 
15438 
  def read(self, iprot):
15439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15441 
      return
15442 
    iprot.readStructBegin()
15443 
    while True:
15444 
      (fname, ftype, fid) = iprot.readFieldBegin()
15445 
      if ftype == TType.STOP:
15446 
        break
15447 
      if fid == 1:
15448 
        if ftype == TType.STRING:
15449 
          self.category = iprot.readString();
15450 
        else:
15451 
          iprot.skip(ftype)
15452 
      elif fid == 2:
15453 
        if ftype == TType.STRING:
15454 
          self.brand = iprot.readString();
15455 
        else:
15456 
          iprot.skip(ftype)
15457 
      else:
15458 
        iprot.skip(ftype)
15459 
      iprot.readFieldEnd()
15460 
    iprot.readStructEnd()
15461 
 
15462 
  def write(self, oprot):
15463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15465 
      return
15466 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15467 
    if self.category is not None:
15468 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15469 
      oprot.writeString(self.category)
15470 
      oprot.writeFieldEnd()
15471 
    if self.brand is not None:
15472 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15473 
      oprot.writeString(self.brand)
15474 
      oprot.writeFieldEnd()
15475 
    oprot.writeFieldStop()
15476 
    oprot.writeStructEnd()
15477 
 
15478 
  def validate(self):
15479 
    return
15480 
 
15481 
 
15482 
  def __repr__(self):
15483 
    L = ['%s=%r' % (key, value)
15484 
      for key, value in self.__dict__.iteritems()]
15485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15486 
 
15487 
  def __eq__(self, other):
15488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15489 
 
15490 
  def __ne__(self, other):
15491 
    return not (self == other)
15492 
 
15493 
class getItemsForMasterSheet_result:
15494 
  """
15495 
  Attributes:
15496 
   - success
15497 
  """
15498 
 
15499 
  thrift_spec = (
15500 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15501 
  )
15502 
 
15503 
  def __init__(self, success=None,):
15504 
    self.success = success
15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 0:
15516 
        if ftype == TType.LIST:
15517 
          self.success = []
9155 kshitij.so 15518 
          (_etype286, _size283) = iprot.readListBegin()
15519 
          for _i287 in xrange(_size283):
15520 
            _elem288 = Item()
15521 
            _elem288.read(iprot)
15522 
            self.success.append(_elem288)
5944 mandeep.dh 15523 
          iprot.readListEnd()
15524 
        else:
15525 
          iprot.skip(ftype)
15526 
      else:
15527 
        iprot.skip(ftype)
15528 
      iprot.readFieldEnd()
15529 
    iprot.readStructEnd()
15530 
 
15531 
  def write(self, oprot):
15532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15534 
      return
15535 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15536 
    if self.success is not None:
15537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15539 
      for iter289 in self.success:
15540 
        iter289.write(oprot)
5944 mandeep.dh 15541 
      oprot.writeListEnd()
15542 
      oprot.writeFieldEnd()
15543 
    oprot.writeFieldStop()
15544 
    oprot.writeStructEnd()
15545 
 
15546 
  def validate(self):
15547 
    return
15548 
 
15549 
 
15550 
  def __repr__(self):
15551 
    L = ['%s=%r' % (key, value)
15552 
      for key, value in self.__dict__.iteritems()]
15553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15554 
 
15555 
  def __eq__(self, other):
15556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15557 
 
15558 
  def __ne__(self, other):
15559 
    return not (self == other)
15560 
 
15561 
class getSimilarItemsCatalogIds_args:
15562 
  """
15563 
  Attributes:
15564 
   - beginIndex
15565 
   - totalItems
15566 
   - itemId
15567 
  """
15568 
 
15569 
  thrift_spec = (
15570 
    None, # 0
15571 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15572 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15573 
    (3, TType.I64, 'itemId', None, None, ), # 3
15574 
  )
15575 
 
15576 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15577 
    self.beginIndex = beginIndex
15578 
    self.totalItems = totalItems
15579 
    self.itemId = itemId
15580 
 
15581 
  def read(self, iprot):
15582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15584 
      return
15585 
    iprot.readStructBegin()
15586 
    while True:
15587 
      (fname, ftype, fid) = iprot.readFieldBegin()
15588 
      if ftype == TType.STOP:
15589 
        break
15590 
      if fid == 1:
15591 
        if ftype == TType.I64:
15592 
          self.beginIndex = iprot.readI64();
15593 
        else:
15594 
          iprot.skip(ftype)
15595 
      elif fid == 2:
15596 
        if ftype == TType.I64:
15597 
          self.totalItems = iprot.readI64();
15598 
        else:
15599 
          iprot.skip(ftype)
15600 
      elif fid == 3:
15601 
        if ftype == TType.I64:
15602 
          self.itemId = iprot.readI64();
15603 
        else:
15604 
          iprot.skip(ftype)
15605 
      else:
15606 
        iprot.skip(ftype)
15607 
      iprot.readFieldEnd()
15608 
    iprot.readStructEnd()
15609 
 
15610 
  def write(self, oprot):
15611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15613 
      return
15614 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15615 
    if self.beginIndex is not None:
15616 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15617 
      oprot.writeI64(self.beginIndex)
15618 
      oprot.writeFieldEnd()
15619 
    if self.totalItems is not None:
15620 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15621 
      oprot.writeI64(self.totalItems)
15622 
      oprot.writeFieldEnd()
15623 
    if self.itemId is not None:
15624 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15625 
      oprot.writeI64(self.itemId)
15626 
      oprot.writeFieldEnd()
15627 
    oprot.writeFieldStop()
15628 
    oprot.writeStructEnd()
15629 
 
15630 
  def validate(self):
15631 
    return
15632 
 
15633 
 
15634 
  def __repr__(self):
15635 
    L = ['%s=%r' % (key, value)
15636 
      for key, value in self.__dict__.iteritems()]
15637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15638 
 
15639 
  def __eq__(self, other):
15640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15641 
 
15642 
  def __ne__(self, other):
15643 
    return not (self == other)
15644 
 
15645 
class getSimilarItemsCatalogIds_result:
15646 
  """
15647 
  Attributes:
15648 
   - success
15649 
  """
15650 
 
15651 
  thrift_spec = (
15652 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15653 
  )
15654 
 
15655 
  def __init__(self, success=None,):
15656 
    self.success = success
15657 
 
15658 
  def read(self, iprot):
15659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15661 
      return
15662 
    iprot.readStructBegin()
15663 
    while True:
15664 
      (fname, ftype, fid) = iprot.readFieldBegin()
15665 
      if ftype == TType.STOP:
15666 
        break
15667 
      if fid == 0:
15668 
        if ftype == TType.LIST:
15669 
          self.success = []
9155 kshitij.so 15670 
          (_etype293, _size290) = iprot.readListBegin()
15671 
          for _i294 in xrange(_size290):
15672 
            _elem295 = iprot.readI64();
15673 
            self.success.append(_elem295)
5944 mandeep.dh 15674 
          iprot.readListEnd()
15675 
        else:
15676 
          iprot.skip(ftype)
15677 
      else:
15678 
        iprot.skip(ftype)
15679 
      iprot.readFieldEnd()
15680 
    iprot.readStructEnd()
15681 
 
15682 
  def write(self, oprot):
15683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15685 
      return
15686 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15687 
    if self.success is not None:
15688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15689 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15690 
      for iter296 in self.success:
15691 
        oprot.writeI64(iter296)
5944 mandeep.dh 15692 
      oprot.writeListEnd()
15693 
      oprot.writeFieldEnd()
15694 
    oprot.writeFieldStop()
15695 
    oprot.writeStructEnd()
15696 
 
15697 
  def validate(self):
15698 
    return
15699 
 
15700 
 
15701 
  def __repr__(self):
15702 
    L = ['%s=%r' % (key, value)
15703 
      for key, value in self.__dict__.iteritems()]
15704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15705 
 
15706 
  def __eq__(self, other):
15707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15708 
 
15709 
  def __ne__(self, other):
15710 
    return not (self == other)
15711 
 
15712 
class addProductNotification_args:
15713 
  """
15714 
  Attributes:
15715 
   - itemId
15716 
   - email
15717 
  """
15718 
 
15719 
  thrift_spec = None
15720 
  def __init__(self, itemId=None, email=None,):
15721 
    self.itemId = itemId
15722 
    self.email = email
15723 
 
15724 
  def read(self, iprot):
15725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15727 
      return
15728 
    iprot.readStructBegin()
15729 
    while True:
15730 
      (fname, ftype, fid) = iprot.readFieldBegin()
15731 
      if ftype == TType.STOP:
15732 
        break
15733 
      if fid == -1:
15734 
        if ftype == TType.I64:
15735 
          self.itemId = iprot.readI64();
15736 
        else:
15737 
          iprot.skip(ftype)
15738 
      elif fid == -2:
15739 
        if ftype == TType.STRING:
15740 
          self.email = iprot.readString();
15741 
        else:
15742 
          iprot.skip(ftype)
15743 
      else:
15744 
        iprot.skip(ftype)
15745 
      iprot.readFieldEnd()
15746 
    iprot.readStructEnd()
15747 
 
15748 
  def write(self, oprot):
15749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15751 
      return
15752 
    oprot.writeStructBegin('addProductNotification_args')
15753 
    if self.email is not None:
15754 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15755 
      oprot.writeString(self.email)
15756 
      oprot.writeFieldEnd()
15757 
    if self.itemId is not None:
15758 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15759 
      oprot.writeI64(self.itemId)
15760 
      oprot.writeFieldEnd()
15761 
    oprot.writeFieldStop()
15762 
    oprot.writeStructEnd()
15763 
 
15764 
  def validate(self):
15765 
    return
15766 
 
15767 
 
15768 
  def __repr__(self):
15769 
    L = ['%s=%r' % (key, value)
15770 
      for key, value in self.__dict__.iteritems()]
15771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15772 
 
15773 
  def __eq__(self, other):
15774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15775 
 
15776 
  def __ne__(self, other):
15777 
    return not (self == other)
15778 
 
15779 
class addProductNotification_result:
15780 
  """
15781 
  Attributes:
15782 
   - success
15783 
  """
15784 
 
15785 
  thrift_spec = (
15786 
    (0, TType.BOOL, 'success', None, None, ), # 0
15787 
  )
15788 
 
15789 
  def __init__(self, success=None,):
15790 
    self.success = success
15791 
 
15792 
  def read(self, iprot):
15793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15795 
      return
15796 
    iprot.readStructBegin()
15797 
    while True:
15798 
      (fname, ftype, fid) = iprot.readFieldBegin()
15799 
      if ftype == TType.STOP:
15800 
        break
15801 
      if fid == 0:
15802 
        if ftype == TType.BOOL:
15803 
          self.success = iprot.readBool();
15804 
        else:
15805 
          iprot.skip(ftype)
15806 
      else:
15807 
        iprot.skip(ftype)
15808 
      iprot.readFieldEnd()
15809 
    iprot.readStructEnd()
15810 
 
15811 
  def write(self, oprot):
15812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15814 
      return
15815 
    oprot.writeStructBegin('addProductNotification_result')
15816 
    if self.success is not None:
15817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15818 
      oprot.writeBool(self.success)
15819 
      oprot.writeFieldEnd()
15820 
    oprot.writeFieldStop()
15821 
    oprot.writeStructEnd()
15822 
 
15823 
  def validate(self):
15824 
    return
15825 
 
15826 
 
15827 
  def __repr__(self):
15828 
    L = ['%s=%r' % (key, value)
15829 
      for key, value in self.__dict__.iteritems()]
15830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15831 
 
15832 
  def __eq__(self, other):
15833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15834 
 
15835 
  def __ne__(self, other):
15836 
    return not (self == other)
15837 
 
15838 
class sendProductNotifications_args:
15839 
 
15840 
  thrift_spec = (
15841 
  )
15842 
 
15843 
  def read(self, iprot):
15844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15846 
      return
15847 
    iprot.readStructBegin()
15848 
    while True:
15849 
      (fname, ftype, fid) = iprot.readFieldBegin()
15850 
      if ftype == TType.STOP:
15851 
        break
15852 
      else:
15853 
        iprot.skip(ftype)
15854 
      iprot.readFieldEnd()
15855 
    iprot.readStructEnd()
15856 
 
15857 
  def write(self, oprot):
15858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15860 
      return
15861 
    oprot.writeStructBegin('sendProductNotifications_args')
15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
15880 
class sendProductNotifications_result:
15881 
  """
15882 
  Attributes:
15883 
   - success
15884 
  """
15885 
 
15886 
  thrift_spec = (
15887 
    (0, TType.BOOL, 'success', None, None, ), # 0
15888 
  )
15889 
 
15890 
  def __init__(self, success=None,):
15891 
    self.success = success
15892 
 
15893 
  def read(self, iprot):
15894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15896 
      return
15897 
    iprot.readStructBegin()
15898 
    while True:
15899 
      (fname, ftype, fid) = iprot.readFieldBegin()
15900 
      if ftype == TType.STOP:
15901 
        break
15902 
      if fid == 0:
15903 
        if ftype == TType.BOOL:
15904 
          self.success = iprot.readBool();
15905 
        else:
15906 
          iprot.skip(ftype)
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_result')
15917 
    if self.success is not None:
15918 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15919 
      oprot.writeBool(self.success)
15920 
      oprot.writeFieldEnd()
15921 
    oprot.writeFieldStop()
15922 
    oprot.writeStructEnd()
15923 
 
15924 
  def validate(self):
15925 
    return
15926 
 
15927 
 
15928 
  def __repr__(self):
15929 
    L = ['%s=%r' % (key, value)
15930 
      for key, value in self.__dict__.iteritems()]
15931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15932 
 
15933 
  def __eq__(self, other):
15934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15935 
 
15936 
  def __ne__(self, other):
15937 
    return not (self == other)
15938 
 
15939 
class getAllBrandsByCategory_args:
15940 
  """
15941 
  Attributes:
15942 
   - categoryId
15943 
  """
15944 
 
15945 
  thrift_spec = (
15946 
    None, # 0
15947 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15948 
  )
15949 
 
15950 
  def __init__(self, categoryId=None,):
15951 
    self.categoryId = categoryId
15952 
 
15953 
  def read(self, iprot):
15954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15956 
      return
15957 
    iprot.readStructBegin()
15958 
    while True:
15959 
      (fname, ftype, fid) = iprot.readFieldBegin()
15960 
      if ftype == TType.STOP:
15961 
        break
15962 
      if fid == 1:
15963 
        if ftype == TType.I64:
15964 
          self.categoryId = iprot.readI64();
15965 
        else:
15966 
          iprot.skip(ftype)
15967 
      else:
15968 
        iprot.skip(ftype)
15969 
      iprot.readFieldEnd()
15970 
    iprot.readStructEnd()
15971 
 
15972 
  def write(self, oprot):
15973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15975 
      return
15976 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15977 
    if self.categoryId is not None:
15978 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15979 
      oprot.writeI64(self.categoryId)
15980 
      oprot.writeFieldEnd()
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
15999 
class getAllBrandsByCategory_result:
16000 
  """
16001 
  Attributes:
16002 
   - success
16003 
  """
16004 
 
16005 
  thrift_spec = (
16006 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16007 
  )
16008 
 
16009 
  def __init__(self, success=None,):
16010 
    self.success = success
16011 
 
16012 
  def read(self, iprot):
16013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16015 
      return
16016 
    iprot.readStructBegin()
16017 
    while True:
16018 
      (fname, ftype, fid) = iprot.readFieldBegin()
16019 
      if ftype == TType.STOP:
16020 
        break
16021 
      if fid == 0:
16022 
        if ftype == TType.LIST:
16023 
          self.success = []
9155 kshitij.so 16024 
          (_etype300, _size297) = iprot.readListBegin()
16025 
          for _i301 in xrange(_size297):
16026 
            _elem302 = iprot.readString();
16027 
            self.success.append(_elem302)
5944 mandeep.dh 16028 
          iprot.readListEnd()
16029 
        else:
16030 
          iprot.skip(ftype)
16031 
      else:
16032 
        iprot.skip(ftype)
16033 
      iprot.readFieldEnd()
16034 
    iprot.readStructEnd()
16035 
 
16036 
  def write(self, oprot):
16037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16039 
      return
16040 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16041 
    if self.success is not None:
16042 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16043 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16044 
      for iter303 in self.success:
16045 
        oprot.writeString(iter303)
5944 mandeep.dh 16046 
      oprot.writeListEnd()
16047 
      oprot.writeFieldEnd()
16048 
    oprot.writeFieldStop()
16049 
    oprot.writeStructEnd()
16050 
 
16051 
  def validate(self):
16052 
    return
16053 
 
16054 
 
16055 
  def __repr__(self):
16056 
    L = ['%s=%r' % (key, value)
16057 
      for key, value in self.__dict__.iteritems()]
16058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16059 
 
16060 
  def __eq__(self, other):
16061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16062 
 
16063 
  def __ne__(self, other):
16064 
    return not (self == other)
16065 
 
16066 
class getAllBrands_args:
16067 
 
16068 
  thrift_spec = (
16069 
  )
16070 
 
16071 
  def read(self, iprot):
16072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16074 
      return
16075 
    iprot.readStructBegin()
16076 
    while True:
16077 
      (fname, ftype, fid) = iprot.readFieldBegin()
16078 
      if ftype == TType.STOP:
16079 
        break
16080 
      else:
16081 
        iprot.skip(ftype)
16082 
      iprot.readFieldEnd()
16083 
    iprot.readStructEnd()
16084 
 
16085 
  def write(self, oprot):
16086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16088 
      return
16089 
    oprot.writeStructBegin('getAllBrands_args')
16090 
    oprot.writeFieldStop()
16091 
    oprot.writeStructEnd()
16092 
 
16093 
  def validate(self):
16094 
    return
16095 
 
16096 
 
16097 
  def __repr__(self):
16098 
    L = ['%s=%r' % (key, value)
16099 
      for key, value in self.__dict__.iteritems()]
16100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16101 
 
16102 
  def __eq__(self, other):
16103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16104 
 
16105 
  def __ne__(self, other):
16106 
    return not (self == other)
16107 
 
16108 
class getAllBrands_result:
16109 
  """
16110 
  Attributes:
16111 
   - success
16112 
  """
16113 
 
16114 
  thrift_spec = (
16115 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16116 
  )
16117 
 
16118 
  def __init__(self, success=None,):
16119 
    self.success = success
16120 
 
16121 
  def read(self, iprot):
16122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16124 
      return
16125 
    iprot.readStructBegin()
16126 
    while True:
16127 
      (fname, ftype, fid) = iprot.readFieldBegin()
16128 
      if ftype == TType.STOP:
16129 
        break
16130 
      if fid == 0:
16131 
        if ftype == TType.LIST:
16132 
          self.success = []
9155 kshitij.so 16133 
          (_etype307, _size304) = iprot.readListBegin()
16134 
          for _i308 in xrange(_size304):
16135 
            _elem309 = iprot.readString();
16136 
            self.success.append(_elem309)
5944 mandeep.dh 16137 
          iprot.readListEnd()
16138 
        else:
16139 
          iprot.skip(ftype)
16140 
      else:
16141 
        iprot.skip(ftype)
16142 
      iprot.readFieldEnd()
16143 
    iprot.readStructEnd()
16144 
 
16145 
  def write(self, oprot):
16146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16148 
      return
16149 
    oprot.writeStructBegin('getAllBrands_result')
16150 
    if self.success is not None:
16151 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16152 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16153 
      for iter310 in self.success:
16154 
        oprot.writeString(iter310)
5944 mandeep.dh 16155 
      oprot.writeListEnd()
16156 
      oprot.writeFieldEnd()
16157 
    oprot.writeFieldStop()
16158 
    oprot.writeStructEnd()
16159 
 
16160 
  def validate(self):
16161 
    return
16162 
 
16163 
 
16164 
  def __repr__(self):
16165 
    L = ['%s=%r' % (key, value)
16166 
      for key, value in self.__dict__.iteritems()]
16167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16168 
 
16169 
  def __eq__(self, other):
16170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16171 
 
16172 
  def __ne__(self, other):
16173 
    return not (self == other)
16174 
 
16175 
class getAllSources_args:
16176 
 
16177 
  thrift_spec = (
16178 
  )
16179 
 
16180 
  def read(self, iprot):
16181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16183 
      return
16184 
    iprot.readStructBegin()
16185 
    while True:
16186 
      (fname, ftype, fid) = iprot.readFieldBegin()
16187 
      if ftype == TType.STOP:
16188 
        break
16189 
      else:
16190 
        iprot.skip(ftype)
16191 
      iprot.readFieldEnd()
16192 
    iprot.readStructEnd()
16193 
 
16194 
  def write(self, oprot):
16195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16197 
      return
16198 
    oprot.writeStructBegin('getAllSources_args')
16199 
    oprot.writeFieldStop()
16200 
    oprot.writeStructEnd()
16201 
 
16202 
  def validate(self):
16203 
    return
16204 
 
16205 
 
16206 
  def __repr__(self):
16207 
    L = ['%s=%r' % (key, value)
16208 
      for key, value in self.__dict__.iteritems()]
16209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16210 
 
16211 
  def __eq__(self, other):
16212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16213 
 
16214 
  def __ne__(self, other):
16215 
    return not (self == other)
16216 
 
16217 
class getAllSources_result:
16218 
  """
16219 
  Attributes:
16220 
   - success
16221 
  """
16222 
 
16223 
  thrift_spec = (
16224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16225 
  )
16226 
 
16227 
  def __init__(self, success=None,):
16228 
    self.success = success
16229 
 
16230 
  def read(self, iprot):
16231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16233 
      return
16234 
    iprot.readStructBegin()
16235 
    while True:
16236 
      (fname, ftype, fid) = iprot.readFieldBegin()
16237 
      if ftype == TType.STOP:
16238 
        break
16239 
      if fid == 0:
16240 
        if ftype == TType.LIST:
16241 
          self.success = []
9155 kshitij.so 16242 
          (_etype314, _size311) = iprot.readListBegin()
16243 
          for _i315 in xrange(_size311):
16244 
            _elem316 = Source()
16245 
            _elem316.read(iprot)
16246 
            self.success.append(_elem316)
5944 mandeep.dh 16247 
          iprot.readListEnd()
16248 
        else:
16249 
          iprot.skip(ftype)
16250 
      else:
16251 
        iprot.skip(ftype)
16252 
      iprot.readFieldEnd()
16253 
    iprot.readStructEnd()
16254 
 
16255 
  def write(self, oprot):
16256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16258 
      return
16259 
    oprot.writeStructBegin('getAllSources_result')
16260 
    if self.success is not None:
16261 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16262 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16263 
      for iter317 in self.success:
16264 
        iter317.write(oprot)
5944 mandeep.dh 16265 
      oprot.writeListEnd()
16266 
      oprot.writeFieldEnd()
16267 
    oprot.writeFieldStop()
16268 
    oprot.writeStructEnd()
16269 
 
16270 
  def validate(self):
16271 
    return
16272 
 
16273 
 
16274 
  def __repr__(self):
16275 
    L = ['%s=%r' % (key, value)
16276 
      for key, value in self.__dict__.iteritems()]
16277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16278 
 
16279 
  def __eq__(self, other):
16280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16281 
 
16282 
  def __ne__(self, other):
16283 
    return not (self == other)
16284 
 
16285 
class getItemPricingBySource_args:
16286 
  """
16287 
  Attributes:
16288 
   - itemId
16289 
   - sourceId
16290 
  """
16291 
 
16292 
  thrift_spec = (
16293 
    None, # 0
16294 
    (1, TType.I64, 'itemId', None, None, ), # 1
16295 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16296 
  )
16297 
 
16298 
  def __init__(self, itemId=None, sourceId=None,):
16299 
    self.itemId = itemId
16300 
    self.sourceId = sourceId
16301 
 
16302 
  def read(self, iprot):
16303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16305 
      return
16306 
    iprot.readStructBegin()
16307 
    while True:
16308 
      (fname, ftype, fid) = iprot.readFieldBegin()
16309 
      if ftype == TType.STOP:
16310 
        break
16311 
      if fid == 1:
16312 
        if ftype == TType.I64:
16313 
          self.itemId = iprot.readI64();
16314 
        else:
16315 
          iprot.skip(ftype)
16316 
      elif fid == 2:
16317 
        if ftype == TType.I64:
16318 
          self.sourceId = iprot.readI64();
16319 
        else:
16320 
          iprot.skip(ftype)
16321 
      else:
16322 
        iprot.skip(ftype)
16323 
      iprot.readFieldEnd()
16324 
    iprot.readStructEnd()
16325 
 
16326 
  def write(self, oprot):
16327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16329 
      return
16330 
    oprot.writeStructBegin('getItemPricingBySource_args')
16331 
    if self.itemId is not None:
16332 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16333 
      oprot.writeI64(self.itemId)
16334 
      oprot.writeFieldEnd()
16335 
    if self.sourceId is not None:
16336 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16337 
      oprot.writeI64(self.sourceId)
16338 
      oprot.writeFieldEnd()
16339 
    oprot.writeFieldStop()
16340 
    oprot.writeStructEnd()
16341 
 
16342 
  def validate(self):
16343 
    return
16344 
 
16345 
 
16346 
  def __repr__(self):
16347 
    L = ['%s=%r' % (key, value)
16348 
      for key, value in self.__dict__.iteritems()]
16349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16350 
 
16351 
  def __eq__(self, other):
16352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16353 
 
16354 
  def __ne__(self, other):
16355 
    return not (self == other)
16356 
 
16357 
class getItemPricingBySource_result:
16358 
  """
16359 
  Attributes:
16360 
   - success
16361 
   - cex
16362 
  """
16363 
 
16364 
  thrift_spec = (
16365 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16366 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16367 
  )
16368 
 
16369 
  def __init__(self, success=None, cex=None,):
16370 
    self.success = success
16371 
    self.cex = cex
16372 
 
16373 
  def read(self, iprot):
16374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16376 
      return
16377 
    iprot.readStructBegin()
16378 
    while True:
16379 
      (fname, ftype, fid) = iprot.readFieldBegin()
16380 
      if ftype == TType.STOP:
16381 
        break
16382 
      if fid == 0:
16383 
        if ftype == TType.STRUCT:
16384 
          self.success = SourceItemPricing()
16385 
          self.success.read(iprot)
16386 
        else:
16387 
          iprot.skip(ftype)
16388 
      elif fid == 1:
16389 
        if ftype == TType.STRUCT:
16390 
          self.cex = CatalogServiceException()
16391 
          self.cex.read(iprot)
16392 
        else:
16393 
          iprot.skip(ftype)
16394 
      else:
16395 
        iprot.skip(ftype)
16396 
      iprot.readFieldEnd()
16397 
    iprot.readStructEnd()
16398 
 
16399 
  def write(self, oprot):
16400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16402 
      return
16403 
    oprot.writeStructBegin('getItemPricingBySource_result')
16404 
    if self.success is not None:
16405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16406 
      self.success.write(oprot)
16407 
      oprot.writeFieldEnd()
16408 
    if self.cex is not None:
16409 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16410 
      self.cex.write(oprot)
16411 
      oprot.writeFieldEnd()
16412 
    oprot.writeFieldStop()
16413 
    oprot.writeStructEnd()
16414 
 
16415 
  def validate(self):
16416 
    return
16417 
 
16418 
 
16419 
  def __repr__(self):
16420 
    L = ['%s=%r' % (key, value)
16421 
      for key, value in self.__dict__.iteritems()]
16422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16423 
 
16424 
  def __eq__(self, other):
16425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16426 
 
16427 
  def __ne__(self, other):
16428 
    return not (self == other)
16429 
 
16430 
class addSourceItemPricing_args:
16431 
  """
16432 
  Attributes:
16433 
   - sourceItemPricing
16434 
  """
16435 
 
16436 
  thrift_spec = (
16437 
    None, # 0
16438 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16439 
  )
16440 
 
16441 
  def __init__(self, sourceItemPricing=None,):
16442 
    self.sourceItemPricing = sourceItemPricing
16443 
 
16444 
  def read(self, iprot):
16445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16447 
      return
16448 
    iprot.readStructBegin()
16449 
    while True:
16450 
      (fname, ftype, fid) = iprot.readFieldBegin()
16451 
      if ftype == TType.STOP:
16452 
        break
16453 
      if fid == 1:
16454 
        if ftype == TType.STRUCT:
16455 
          self.sourceItemPricing = SourceItemPricing()
16456 
          self.sourceItemPricing.read(iprot)
16457 
        else:
16458 
          iprot.skip(ftype)
16459 
      else:
16460 
        iprot.skip(ftype)
16461 
      iprot.readFieldEnd()
16462 
    iprot.readStructEnd()
16463 
 
16464 
  def write(self, oprot):
16465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16467 
      return
16468 
    oprot.writeStructBegin('addSourceItemPricing_args')
16469 
    if self.sourceItemPricing is not None:
16470 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16471 
      self.sourceItemPricing.write(oprot)
16472 
      oprot.writeFieldEnd()
16473 
    oprot.writeFieldStop()
16474 
    oprot.writeStructEnd()
16475 
 
16476 
  def validate(self):
16477 
    return
16478 
 
16479 
 
16480 
  def __repr__(self):
16481 
    L = ['%s=%r' % (key, value)
16482 
      for key, value in self.__dict__.iteritems()]
16483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16484 
 
16485 
  def __eq__(self, other):
16486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16487 
 
16488 
  def __ne__(self, other):
16489 
    return not (self == other)
16490 
 
16491 
class addSourceItemPricing_result:
16492 
  """
16493 
  Attributes:
16494 
   - cex
16495 
  """
16496 
 
16497 
  thrift_spec = (
16498 
    None, # 0
16499 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16500 
  )
16501 
 
16502 
  def __init__(self, cex=None,):
16503 
    self.cex = cex
16504 
 
16505 
  def read(self, iprot):
16506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16508 
      return
16509 
    iprot.readStructBegin()
16510 
    while True:
16511 
      (fname, ftype, fid) = iprot.readFieldBegin()
16512 
      if ftype == TType.STOP:
16513 
        break
16514 
      if fid == 1:
16515 
        if ftype == TType.STRUCT:
16516 
          self.cex = CatalogServiceException()
16517 
          self.cex.read(iprot)
16518 
        else:
16519 
          iprot.skip(ftype)
16520 
      else:
16521 
        iprot.skip(ftype)
16522 
      iprot.readFieldEnd()
16523 
    iprot.readStructEnd()
16524 
 
16525 
  def write(self, oprot):
16526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16528 
      return
16529 
    oprot.writeStructBegin('addSourceItemPricing_result')
16530 
    if self.cex is not None:
16531 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16532 
      self.cex.write(oprot)
16533 
      oprot.writeFieldEnd()
16534 
    oprot.writeFieldStop()
16535 
    oprot.writeStructEnd()
16536 
 
16537 
  def validate(self):
16538 
    return
16539 
 
16540 
 
16541 
  def __repr__(self):
16542 
    L = ['%s=%r' % (key, value)
16543 
      for key, value in self.__dict__.iteritems()]
16544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16545 
 
16546 
  def __eq__(self, other):
16547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16548 
 
16549 
  def __ne__(self, other):
16550 
    return not (self == other)
16551 
 
16552 
class getAllSourcePricing_args:
16553 
  """
16554 
  Attributes:
16555 
   - itemId
16556 
  """
16557 
 
16558 
  thrift_spec = (
16559 
    None, # 0
16560 
    (1, TType.I64, 'itemId', None, None, ), # 1
16561 
  )
16562 
 
16563 
  def __init__(self, itemId=None,):
16564 
    self.itemId = itemId
16565 
 
16566 
  def read(self, iprot):
16567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16569 
      return
16570 
    iprot.readStructBegin()
16571 
    while True:
16572 
      (fname, ftype, fid) = iprot.readFieldBegin()
16573 
      if ftype == TType.STOP:
16574 
        break
16575 
      if fid == 1:
16576 
        if ftype == TType.I64:
16577 
          self.itemId = iprot.readI64();
16578 
        else:
16579 
          iprot.skip(ftype)
16580 
      else:
16581 
        iprot.skip(ftype)
16582 
      iprot.readFieldEnd()
16583 
    iprot.readStructEnd()
16584 
 
16585 
  def write(self, oprot):
16586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16588 
      return
16589 
    oprot.writeStructBegin('getAllSourcePricing_args')
16590 
    if self.itemId is not None:
16591 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16592 
      oprot.writeI64(self.itemId)
16593 
      oprot.writeFieldEnd()
16594 
    oprot.writeFieldStop()
16595 
    oprot.writeStructEnd()
16596 
 
16597 
  def validate(self):
16598 
    return
16599 
 
16600 
 
16601 
  def __repr__(self):
16602 
    L = ['%s=%r' % (key, value)
16603 
      for key, value in self.__dict__.iteritems()]
16604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16605 
 
16606 
  def __eq__(self, other):
16607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16608 
 
16609 
  def __ne__(self, other):
16610 
    return not (self == other)
16611 
 
16612 
class getAllSourcePricing_result:
16613 
  """
16614 
  Attributes:
16615 
   - success
16616 
   - cex
16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16621 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16622 
  )
16623 
 
16624 
  def __init__(self, success=None, cex=None,):
16625 
    self.success = success
16626 
    self.cex = cex
16627 
 
16628 
  def read(self, iprot):
16629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16631 
      return
16632 
    iprot.readStructBegin()
16633 
    while True:
16634 
      (fname, ftype, fid) = iprot.readFieldBegin()
16635 
      if ftype == TType.STOP:
16636 
        break
16637 
      if fid == 0:
16638 
        if ftype == TType.LIST:
16639 
          self.success = []
9155 kshitij.so 16640 
          (_etype321, _size318) = iprot.readListBegin()
16641 
          for _i322 in xrange(_size318):
16642 
            _elem323 = SourceItemPricing()
16643 
            _elem323.read(iprot)
16644 
            self.success.append(_elem323)
5944 mandeep.dh 16645 
          iprot.readListEnd()
16646 
        else:
16647 
          iprot.skip(ftype)
16648 
      elif fid == 1:
16649 
        if ftype == TType.STRUCT:
16650 
          self.cex = CatalogServiceException()
16651 
          self.cex.read(iprot)
16652 
        else:
16653 
          iprot.skip(ftype)
16654 
      else:
16655 
        iprot.skip(ftype)
16656 
      iprot.readFieldEnd()
16657 
    iprot.readStructEnd()
16658 
 
16659 
  def write(self, oprot):
16660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16662 
      return
16663 
    oprot.writeStructBegin('getAllSourcePricing_result')
16664 
    if self.success is not None:
16665 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16666 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16667 
      for iter324 in self.success:
16668 
        iter324.write(oprot)
5944 mandeep.dh 16669 
      oprot.writeListEnd()
16670 
      oprot.writeFieldEnd()
16671 
    if self.cex is not None:
16672 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16673 
      self.cex.write(oprot)
16674 
      oprot.writeFieldEnd()
16675 
    oprot.writeFieldStop()
16676 
    oprot.writeStructEnd()
16677 
 
16678 
  def validate(self):
16679 
    return
16680 
 
16681 
 
16682 
  def __repr__(self):
16683 
    L = ['%s=%r' % (key, value)
16684 
      for key, value in self.__dict__.iteritems()]
16685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16686 
 
16687 
  def __eq__(self, other):
16688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16689 
 
16690 
  def __ne__(self, other):
16691 
    return not (self == other)
16692 
 
16693 
class getItemForSource_args:
16694 
  """
16695 
  Attributes:
16696 
   - item_id
16697 
   - sourceId
16698 
  """
16699 
 
16700 
  thrift_spec = (
16701 
    None, # 0
16702 
    (1, TType.I64, 'item_id', None, None, ), # 1
16703 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16704 
  )
16705 
 
16706 
  def __init__(self, item_id=None, sourceId=None,):
16707 
    self.item_id = item_id
16708 
    self.sourceId = sourceId
16709 
 
16710 
  def read(self, iprot):
16711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16713 
      return
16714 
    iprot.readStructBegin()
16715 
    while True:
16716 
      (fname, ftype, fid) = iprot.readFieldBegin()
16717 
      if ftype == TType.STOP:
16718 
        break
16719 
      if fid == 1:
16720 
        if ftype == TType.I64:
16721 
          self.item_id = iprot.readI64();
16722 
        else:
16723 
          iprot.skip(ftype)
16724 
      elif fid == 2:
16725 
        if ftype == TType.I64:
16726 
          self.sourceId = iprot.readI64();
16727 
        else:
16728 
          iprot.skip(ftype)
16729 
      else:
16730 
        iprot.skip(ftype)
16731 
      iprot.readFieldEnd()
16732 
    iprot.readStructEnd()
16733 
 
16734 
  def write(self, oprot):
16735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16737 
      return
16738 
    oprot.writeStructBegin('getItemForSource_args')
16739 
    if self.item_id is not None:
16740 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16741 
      oprot.writeI64(self.item_id)
16742 
      oprot.writeFieldEnd()
16743 
    if self.sourceId is not None:
16744 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16745 
      oprot.writeI64(self.sourceId)
16746 
      oprot.writeFieldEnd()
16747 
    oprot.writeFieldStop()
16748 
    oprot.writeStructEnd()
16749 
 
16750 
  def validate(self):
16751 
    return
16752 
 
16753 
 
16754 
  def __repr__(self):
16755 
    L = ['%s=%r' % (key, value)
16756 
      for key, value in self.__dict__.iteritems()]
16757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16758 
 
16759 
  def __eq__(self, other):
16760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16761 
 
16762 
  def __ne__(self, other):
16763 
    return not (self == other)
16764 
 
16765 
class getItemForSource_result:
16766 
  """
16767 
  Attributes:
16768 
   - success
16769 
   - cex
16770 
  """
16771 
 
16772 
  thrift_spec = (
16773 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16774 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16775 
  )
16776 
 
16777 
  def __init__(self, success=None, cex=None,):
16778 
    self.success = success
16779 
    self.cex = cex
16780 
 
16781 
  def read(self, iprot):
16782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16784 
      return
16785 
    iprot.readStructBegin()
16786 
    while True:
16787 
      (fname, ftype, fid) = iprot.readFieldBegin()
16788 
      if ftype == TType.STOP:
16789 
        break
16790 
      if fid == 0:
16791 
        if ftype == TType.STRUCT:
16792 
          self.success = Item()
16793 
          self.success.read(iprot)
16794 
        else:
16795 
          iprot.skip(ftype)
16796 
      elif fid == 1:
16797 
        if ftype == TType.STRUCT:
16798 
          self.cex = CatalogServiceException()
16799 
          self.cex.read(iprot)
16800 
        else:
16801 
          iprot.skip(ftype)
16802 
      else:
16803 
        iprot.skip(ftype)
16804 
      iprot.readFieldEnd()
16805 
    iprot.readStructEnd()
16806 
 
16807 
  def write(self, oprot):
16808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16810 
      return
16811 
    oprot.writeStructBegin('getItemForSource_result')
16812 
    if self.success is not None:
16813 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16814 
      self.success.write(oprot)
16815 
      oprot.writeFieldEnd()
16816 
    if self.cex is not None:
16817 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16818 
      self.cex.write(oprot)
16819 
      oprot.writeFieldEnd()
16820 
    oprot.writeFieldStop()
16821 
    oprot.writeStructEnd()
16822 
 
16823 
  def validate(self):
16824 
    return
16825 
 
16826 
 
16827 
  def __repr__(self):
16828 
    L = ['%s=%r' % (key, value)
16829 
      for key, value in self.__dict__.iteritems()]
16830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16831 
 
16832 
  def __eq__(self, other):
16833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16834 
 
16835 
  def __ne__(self, other):
16836 
    return not (self == other)
16837 
 
16838 
class searchItemsInRange_args:
16839 
  """
16840 
  Attributes:
16841 
   - searchTerms
16842 
   - offset
16843 
   - limit
16844 
  """
16845 
 
16846 
  thrift_spec = (
16847 
    None, # 0
16848 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16849 
    (2, TType.I64, 'offset', None, None, ), # 2
16850 
    (3, TType.I64, 'limit', None, None, ), # 3
16851 
  )
16852 
 
16853 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16854 
    self.searchTerms = searchTerms
16855 
    self.offset = offset
16856 
    self.limit = limit
16857 
 
16858 
  def read(self, iprot):
16859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16861 
      return
16862 
    iprot.readStructBegin()
16863 
    while True:
16864 
      (fname, ftype, fid) = iprot.readFieldBegin()
16865 
      if ftype == TType.STOP:
16866 
        break
16867 
      if fid == 1:
16868 
        if ftype == TType.LIST:
16869 
          self.searchTerms = []
9155 kshitij.so 16870 
          (_etype328, _size325) = iprot.readListBegin()
16871 
          for _i329 in xrange(_size325):
16872 
            _elem330 = iprot.readString();
16873 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16874 
          iprot.readListEnd()
16875 
        else:
16876 
          iprot.skip(ftype)
16877 
      elif fid == 2:
16878 
        if ftype == TType.I64:
16879 
          self.offset = iprot.readI64();
16880 
        else:
16881 
          iprot.skip(ftype)
16882 
      elif fid == 3:
16883 
        if ftype == TType.I64:
16884 
          self.limit = iprot.readI64();
16885 
        else:
16886 
          iprot.skip(ftype)
16887 
      else:
16888 
        iprot.skip(ftype)
16889 
      iprot.readFieldEnd()
16890 
    iprot.readStructEnd()
16891 
 
16892 
  def write(self, oprot):
16893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16895 
      return
16896 
    oprot.writeStructBegin('searchItemsInRange_args')
16897 
    if self.searchTerms is not None:
16898 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16899 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16900 
      for iter331 in self.searchTerms:
16901 
        oprot.writeString(iter331)
5944 mandeep.dh 16902 
      oprot.writeListEnd()
16903 
      oprot.writeFieldEnd()
16904 
    if self.offset is not None:
16905 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16906 
      oprot.writeI64(self.offset)
16907 
      oprot.writeFieldEnd()
16908 
    if self.limit is not None:
16909 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16910 
      oprot.writeI64(self.limit)
16911 
      oprot.writeFieldEnd()
16912 
    oprot.writeFieldStop()
16913 
    oprot.writeStructEnd()
16914 
 
16915 
  def validate(self):
16916 
    return
16917 
 
16918 
 
16919 
  def __repr__(self):
16920 
    L = ['%s=%r' % (key, value)
16921 
      for key, value in self.__dict__.iteritems()]
16922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16923 
 
16924 
  def __eq__(self, other):
16925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16926 
 
16927 
  def __ne__(self, other):
16928 
    return not (self == other)
16929 
 
16930 
class searchItemsInRange_result:
16931 
  """
16932 
  Attributes:
16933 
   - success
16934 
  """
16935 
 
16936 
  thrift_spec = (
16937 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16938 
  )
16939 
 
16940 
  def __init__(self, success=None,):
16941 
    self.success = success
16942 
 
16943 
  def read(self, iprot):
16944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16946 
      return
16947 
    iprot.readStructBegin()
16948 
    while True:
16949 
      (fname, ftype, fid) = iprot.readFieldBegin()
16950 
      if ftype == TType.STOP:
16951 
        break
16952 
      if fid == 0:
16953 
        if ftype == TType.LIST:
16954 
          self.success = []
9155 kshitij.so 16955 
          (_etype335, _size332) = iprot.readListBegin()
16956 
          for _i336 in xrange(_size332):
16957 
            _elem337 = Item()
16958 
            _elem337.read(iprot)
16959 
            self.success.append(_elem337)
5944 mandeep.dh 16960 
          iprot.readListEnd()
16961 
        else:
16962 
          iprot.skip(ftype)
16963 
      else:
16964 
        iprot.skip(ftype)
16965 
      iprot.readFieldEnd()
16966 
    iprot.readStructEnd()
16967 
 
16968 
  def write(self, oprot):
16969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16971 
      return
16972 
    oprot.writeStructBegin('searchItemsInRange_result')
16973 
    if self.success is not None:
16974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16976 
      for iter338 in self.success:
16977 
        iter338.write(oprot)
5944 mandeep.dh 16978 
      oprot.writeListEnd()
16979 
      oprot.writeFieldEnd()
16980 
    oprot.writeFieldStop()
16981 
    oprot.writeStructEnd()
16982 
 
16983 
  def validate(self):
16984 
    return
16985 
 
16986 
 
16987 
  def __repr__(self):
16988 
    L = ['%s=%r' % (key, value)
16989 
      for key, value in self.__dict__.iteritems()]
16990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16991 
 
16992 
  def __eq__(self, other):
16993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16994 
 
16995 
  def __ne__(self, other):
16996 
    return not (self == other)
16997 
 
16998 
class getSearchResultCount_args:
16999 
  """
17000 
  Attributes:
17001 
   - searchTerms
17002 
  """
17003 
 
17004 
  thrift_spec = (
17005 
    None, # 0
17006 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17007 
  )
17008 
 
17009 
  def __init__(self, searchTerms=None,):
17010 
    self.searchTerms = searchTerms
17011 
 
17012 
  def read(self, iprot):
17013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17015 
      return
17016 
    iprot.readStructBegin()
17017 
    while True:
17018 
      (fname, ftype, fid) = iprot.readFieldBegin()
17019 
      if ftype == TType.STOP:
17020 
        break
17021 
      if fid == 1:
17022 
        if ftype == TType.LIST:
17023 
          self.searchTerms = []
9155 kshitij.so 17024 
          (_etype342, _size339) = iprot.readListBegin()
17025 
          for _i343 in xrange(_size339):
17026 
            _elem344 = iprot.readString();
17027 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17028 
          iprot.readListEnd()
17029 
        else:
17030 
          iprot.skip(ftype)
17031 
      else:
17032 
        iprot.skip(ftype)
17033 
      iprot.readFieldEnd()
17034 
    iprot.readStructEnd()
17035 
 
17036 
  def write(self, oprot):
17037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17039 
      return
17040 
    oprot.writeStructBegin('getSearchResultCount_args')
17041 
    if self.searchTerms is not None:
17042 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17043 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17044 
      for iter345 in self.searchTerms:
17045 
        oprot.writeString(iter345)
5944 mandeep.dh 17046 
      oprot.writeListEnd()
17047 
      oprot.writeFieldEnd()
17048 
    oprot.writeFieldStop()
17049 
    oprot.writeStructEnd()
17050 
 
17051 
  def validate(self):
17052 
    return
17053 
 
17054 
 
17055 
  def __repr__(self):
17056 
    L = ['%s=%r' % (key, value)
17057 
      for key, value in self.__dict__.iteritems()]
17058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17059 
 
17060 
  def __eq__(self, other):
17061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17062 
 
17063 
  def __ne__(self, other):
17064 
    return not (self == other)
17065 
 
17066 
class getSearchResultCount_result:
17067 
  """
17068 
  Attributes:
17069 
   - success
17070 
  """
17071 
 
17072 
  thrift_spec = (
17073 
    (0, TType.I32, 'success', None, None, ), # 0
17074 
  )
17075 
 
17076 
  def __init__(self, success=None,):
17077 
    self.success = success
17078 
 
17079 
  def read(self, iprot):
17080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17082 
      return
17083 
    iprot.readStructBegin()
17084 
    while True:
17085 
      (fname, ftype, fid) = iprot.readFieldBegin()
17086 
      if ftype == TType.STOP:
17087 
        break
17088 
      if fid == 0:
17089 
        if ftype == TType.I32:
17090 
          self.success = iprot.readI32();
17091 
        else:
17092 
          iprot.skip(ftype)
17093 
      else:
17094 
        iprot.skip(ftype)
17095 
      iprot.readFieldEnd()
17096 
    iprot.readStructEnd()
17097 
 
17098 
  def write(self, oprot):
17099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17101 
      return
17102 
    oprot.writeStructBegin('getSearchResultCount_result')
17103 
    if self.success is not None:
17104 
      oprot.writeFieldBegin('success', TType.I32, 0)
17105 
      oprot.writeI32(self.success)
17106 
      oprot.writeFieldEnd()
17107 
    oprot.writeFieldStop()
17108 
    oprot.writeStructEnd()
17109 
 
17110 
  def validate(self):
17111 
    return
17112 
 
17113 
 
17114 
  def __repr__(self):
17115 
    L = ['%s=%r' % (key, value)
17116 
      for key, value in self.__dict__.iteritems()]
17117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17118 
 
17119 
  def __eq__(self, other):
17120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17121 
 
17122 
  def __ne__(self, other):
17123 
    return not (self == other)
17124 
 
17125 
class getProductNotifications_args:
17126 
  """
17127 
  Attributes:
17128 
   - startDateTime
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    None, # 0
17133 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17134 
  )
17135 
 
17136 
  def __init__(self, startDateTime=None,):
17137 
    self.startDateTime = startDateTime
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      if fid == 1:
17149 
        if ftype == TType.I64:
17150 
          self.startDateTime = iprot.readI64();
17151 
        else:
17152 
          iprot.skip(ftype)
17153 
      else:
17154 
        iprot.skip(ftype)
17155 
      iprot.readFieldEnd()
17156 
    iprot.readStructEnd()
17157 
 
17158 
  def write(self, oprot):
17159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17161 
      return
17162 
    oprot.writeStructBegin('getProductNotifications_args')
17163 
    if self.startDateTime is not None:
17164 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17165 
      oprot.writeI64(self.startDateTime)
17166 
      oprot.writeFieldEnd()
17167 
    oprot.writeFieldStop()
17168 
    oprot.writeStructEnd()
17169 
 
17170 
  def validate(self):
17171 
    return
17172 
 
17173 
 
17174 
  def __repr__(self):
17175 
    L = ['%s=%r' % (key, value)
17176 
      for key, value in self.__dict__.iteritems()]
17177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17178 
 
17179 
  def __eq__(self, other):
17180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17181 
 
17182 
  def __ne__(self, other):
17183 
    return not (self == other)
17184 
 
17185 
class getProductNotifications_result:
17186 
  """
17187 
  Attributes:
17188 
   - success
17189 
  """
17190 
 
17191 
  thrift_spec = (
17192 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17193 
  )
17194 
 
17195 
  def __init__(self, success=None,):
17196 
    self.success = success
17197 
 
17198 
  def read(self, iprot):
17199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17201 
      return
17202 
    iprot.readStructBegin()
17203 
    while True:
17204 
      (fname, ftype, fid) = iprot.readFieldBegin()
17205 
      if ftype == TType.STOP:
17206 
        break
17207 
      if fid == 0:
17208 
        if ftype == TType.LIST:
17209 
          self.success = []
9155 kshitij.so 17210 
          (_etype349, _size346) = iprot.readListBegin()
17211 
          for _i350 in xrange(_size346):
17212 
            _elem351 = ProductNotificationRequest()
17213 
            _elem351.read(iprot)
17214 
            self.success.append(_elem351)
5944 mandeep.dh 17215 
          iprot.readListEnd()
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
17227 
    oprot.writeStructBegin('getProductNotifications_result')
17228 
    if self.success is not None:
17229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17231 
      for iter352 in self.success:
17232 
        iter352.write(oprot)
5944 mandeep.dh 17233 
      oprot.writeListEnd()
17234 
      oprot.writeFieldEnd()
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
17253 
class getProductNotificationRequestCount_args:
17254 
  """
17255 
  Attributes:
17256 
   - startDateTime
7897 amar.kumar 17257 
   - categoryId
5944 mandeep.dh 17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    None, # 0
17262 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17263 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17264 
  )
17265 
 
7897 amar.kumar 17266 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17267 
    self.startDateTime = startDateTime
7897 amar.kumar 17268 
    self.categoryId = categoryId
5944 mandeep.dh 17269 
 
17270 
  def read(self, iprot):
17271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17273 
      return
17274 
    iprot.readStructBegin()
17275 
    while True:
17276 
      (fname, ftype, fid) = iprot.readFieldBegin()
17277 
      if ftype == TType.STOP:
17278 
        break
17279 
      if fid == 1:
17280 
        if ftype == TType.I64:
17281 
          self.startDateTime = iprot.readI64();
17282 
        else:
17283 
          iprot.skip(ftype)
7897 amar.kumar 17284 
      elif fid == 2:
17285 
        if ftype == TType.I64:
17286 
          self.categoryId = iprot.readI64();
17287 
        else:
17288 
          iprot.skip(ftype)
5944 mandeep.dh 17289 
      else:
17290 
        iprot.skip(ftype)
17291 
      iprot.readFieldEnd()
17292 
    iprot.readStructEnd()
17293 
 
17294 
  def write(self, oprot):
17295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17297 
      return
17298 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17299 
    if self.startDateTime is not None:
17300 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17301 
      oprot.writeI64(self.startDateTime)
17302 
      oprot.writeFieldEnd()
7897 amar.kumar 17303 
    if self.categoryId is not None:
17304 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17305 
      oprot.writeI64(self.categoryId)
17306 
      oprot.writeFieldEnd()
5944 mandeep.dh 17307 
    oprot.writeFieldStop()
17308 
    oprot.writeStructEnd()
17309 
 
17310 
  def validate(self):
17311 
    return
17312 
 
17313 
 
17314 
  def __repr__(self):
17315 
    L = ['%s=%r' % (key, value)
17316 
      for key, value in self.__dict__.iteritems()]
17317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17318 
 
17319 
  def __eq__(self, other):
17320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17321 
 
17322 
  def __ne__(self, other):
17323 
    return not (self == other)
17324 
 
17325 
class getProductNotificationRequestCount_result:
17326 
  """
17327 
  Attributes:
17328 
   - success
17329 
  """
17330 
 
17331 
  thrift_spec = (
17332 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17333 
  )
17334 
 
17335 
  def __init__(self, success=None,):
17336 
    self.success = success
17337 
 
17338 
  def read(self, iprot):
17339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17341 
      return
17342 
    iprot.readStructBegin()
17343 
    while True:
17344 
      (fname, ftype, fid) = iprot.readFieldBegin()
17345 
      if ftype == TType.STOP:
17346 
        break
17347 
      if fid == 0:
17348 
        if ftype == TType.LIST:
17349 
          self.success = []
9155 kshitij.so 17350 
          (_etype356, _size353) = iprot.readListBegin()
17351 
          for _i357 in xrange(_size353):
17352 
            _elem358 = ProductNotificationRequestCount()
17353 
            _elem358.read(iprot)
17354 
            self.success.append(_elem358)
5944 mandeep.dh 17355 
          iprot.readListEnd()
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      else:
17359 
        iprot.skip(ftype)
17360 
      iprot.readFieldEnd()
17361 
    iprot.readStructEnd()
17362 
 
17363 
  def write(self, oprot):
17364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17366 
      return
17367 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17368 
    if self.success is not None:
17369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17371 
      for iter359 in self.success:
17372 
        iter359.write(oprot)
5944 mandeep.dh 17373 
      oprot.writeListEnd()
17374 
      oprot.writeFieldEnd()
17375 
    oprot.writeFieldStop()
17376 
    oprot.writeStructEnd()
17377 
 
17378 
  def validate(self):
17379 
    return
17380 
 
17381 
 
17382 
  def __repr__(self):
17383 
    L = ['%s=%r' % (key, value)
17384 
      for key, value in self.__dict__.iteritems()]
17385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17386 
 
17387 
  def __eq__(self, other):
17388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17389 
 
17390 
  def __ne__(self, other):
17391 
    return not (self == other)
17392 
 
17393 
class addAuthorizationLog_args:
17394 
  """
17395 
  Attributes:
17396 
   - itemId
17397 
   - username
17398 
   - reason
17399 
  """
17400 
 
17401 
  thrift_spec = (
17402 
    None, # 0
17403 
    (1, TType.I64, 'itemId', None, None, ), # 1
17404 
    (2, TType.STRING, 'username', None, None, ), # 2
17405 
    (3, TType.STRING, 'reason', None, None, ), # 3
17406 
  )
17407 
 
17408 
  def __init__(self, itemId=None, username=None, reason=None,):
17409 
    self.itemId = itemId
17410 
    self.username = username
17411 
    self.reason = reason
17412 
 
17413 
  def read(self, iprot):
17414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17416 
      return
17417 
    iprot.readStructBegin()
17418 
    while True:
17419 
      (fname, ftype, fid) = iprot.readFieldBegin()
17420 
      if ftype == TType.STOP:
17421 
        break
17422 
      if fid == 1:
17423 
        if ftype == TType.I64:
17424 
          self.itemId = iprot.readI64();
17425 
        else:
17426 
          iprot.skip(ftype)
17427 
      elif fid == 2:
17428 
        if ftype == TType.STRING:
17429 
          self.username = iprot.readString();
17430 
        else:
17431 
          iprot.skip(ftype)
17432 
      elif fid == 3:
17433 
        if ftype == TType.STRING:
17434 
          self.reason = iprot.readString();
17435 
        else:
17436 
          iprot.skip(ftype)
17437 
      else:
17438 
        iprot.skip(ftype)
17439 
      iprot.readFieldEnd()
17440 
    iprot.readStructEnd()
17441 
 
17442 
  def write(self, oprot):
17443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17445 
      return
17446 
    oprot.writeStructBegin('addAuthorizationLog_args')
17447 
    if self.itemId is not None:
17448 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17449 
      oprot.writeI64(self.itemId)
17450 
      oprot.writeFieldEnd()
17451 
    if self.username is not None:
17452 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17453 
      oprot.writeString(self.username)
17454 
      oprot.writeFieldEnd()
17455 
    if self.reason is not None:
17456 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17457 
      oprot.writeString(self.reason)
17458 
      oprot.writeFieldEnd()
17459 
    oprot.writeFieldStop()
17460 
    oprot.writeStructEnd()
17461 
 
17462 
  def validate(self):
17463 
    return
17464 
 
17465 
 
17466 
  def __repr__(self):
17467 
    L = ['%s=%r' % (key, value)
17468 
      for key, value in self.__dict__.iteritems()]
17469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17470 
 
17471 
  def __eq__(self, other):
17472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17473 
 
17474 
  def __ne__(self, other):
17475 
    return not (self == other)
17476 
 
17477 
class addAuthorizationLog_result:
17478 
  """
17479 
  Attributes:
17480 
   - success
17481 
   - cex
17482 
  """
17483 
 
17484 
  thrift_spec = (
17485 
    (0, TType.BOOL, 'success', None, None, ), # 0
17486 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17487 
  )
17488 
 
17489 
  def __init__(self, success=None, cex=None,):
17490 
    self.success = success
17491 
    self.cex = cex
17492 
 
17493 
  def read(self, iprot):
17494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17496 
      return
17497 
    iprot.readStructBegin()
17498 
    while True:
17499 
      (fname, ftype, fid) = iprot.readFieldBegin()
17500 
      if ftype == TType.STOP:
17501 
        break
17502 
      if fid == 0:
17503 
        if ftype == TType.BOOL:
17504 
          self.success = iprot.readBool();
17505 
        else:
17506 
          iprot.skip(ftype)
17507 
      elif fid == 1:
17508 
        if ftype == TType.STRUCT:
17509 
          self.cex = CatalogServiceException()
17510 
          self.cex.read(iprot)
17511 
        else:
17512 
          iprot.skip(ftype)
17513 
      else:
17514 
        iprot.skip(ftype)
17515 
      iprot.readFieldEnd()
17516 
    iprot.readStructEnd()
17517 
 
17518 
  def write(self, oprot):
17519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17521 
      return
17522 
    oprot.writeStructBegin('addAuthorizationLog_result')
17523 
    if self.success is not None:
17524 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17525 
      oprot.writeBool(self.success)
17526 
      oprot.writeFieldEnd()
17527 
    if self.cex is not None:
17528 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17529 
      self.cex.write(oprot)
17530 
      oprot.writeFieldEnd()
17531 
    oprot.writeFieldStop()
17532 
    oprot.writeStructEnd()
17533 
 
17534 
  def validate(self):
17535 
    return
17536 
 
17537 
 
17538 
  def __repr__(self):
17539 
    L = ['%s=%r' % (key, value)
17540 
      for key, value in self.__dict__.iteritems()]
17541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17542 
 
17543 
  def __eq__(self, other):
17544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17545 
 
17546 
  def __ne__(self, other):
17547 
    return not (self == other)
17548 
 
17549 
class addupdateVoucherForItem_args:
17550 
  """
17551 
  Attributes:
17552 
   - catalog_item_id
17553 
   - voucherType
17554 
   - voucherAmount
17555 
  """
17556 
 
17557 
  thrift_spec = (
17558 
    None, # 0
17559 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17560 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17561 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17562 
  )
17563 
 
17564 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17565 
    self.catalog_item_id = catalog_item_id
17566 
    self.voucherType = voucherType
17567 
    self.voucherAmount = voucherAmount
17568 
 
17569 
  def read(self, iprot):
17570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17572 
      return
17573 
    iprot.readStructBegin()
17574 
    while True:
17575 
      (fname, ftype, fid) = iprot.readFieldBegin()
17576 
      if ftype == TType.STOP:
17577 
        break
17578 
      if fid == 1:
17579 
        if ftype == TType.I64:
17580 
          self.catalog_item_id = iprot.readI64();
17581 
        else:
17582 
          iprot.skip(ftype)
17583 
      elif fid == 2:
17584 
        if ftype == TType.I64:
17585 
          self.voucherType = iprot.readI64();
17586 
        else:
17587 
          iprot.skip(ftype)
17588 
      elif fid == 3:
17589 
        if ftype == TType.I64:
17590 
          self.voucherAmount = iprot.readI64();
17591 
        else:
17592 
          iprot.skip(ftype)
17593 
      else:
17594 
        iprot.skip(ftype)
17595 
      iprot.readFieldEnd()
17596 
    iprot.readStructEnd()
17597 
 
17598 
  def write(self, oprot):
17599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17601 
      return
17602 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17603 
    if self.catalog_item_id is not None:
17604 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17605 
      oprot.writeI64(self.catalog_item_id)
17606 
      oprot.writeFieldEnd()
17607 
    if self.voucherType is not None:
17608 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17609 
      oprot.writeI64(self.voucherType)
17610 
      oprot.writeFieldEnd()
17611 
    if self.voucherAmount is not None:
17612 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17613 
      oprot.writeI64(self.voucherAmount)
17614 
      oprot.writeFieldEnd()
17615 
    oprot.writeFieldStop()
17616 
    oprot.writeStructEnd()
17617 
 
17618 
  def validate(self):
17619 
    return
17620 
 
17621 
 
17622 
  def __repr__(self):
17623 
    L = ['%s=%r' % (key, value)
17624 
      for key, value in self.__dict__.iteritems()]
17625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17626 
 
17627 
  def __eq__(self, other):
17628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17629 
 
17630 
  def __ne__(self, other):
17631 
    return not (self == other)
17632 
 
17633 
class addupdateVoucherForItem_result:
17634 
  """
17635 
  Attributes:
17636 
   - success
17637 
   - cex
17638 
  """
17639 
 
17640 
  thrift_spec = (
17641 
    (0, TType.BOOL, 'success', None, None, ), # 0
17642 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17643 
  )
17644 
 
17645 
  def __init__(self, success=None, cex=None,):
17646 
    self.success = success
17647 
    self.cex = cex
17648 
 
17649 
  def read(self, iprot):
17650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17652 
      return
17653 
    iprot.readStructBegin()
17654 
    while True:
17655 
      (fname, ftype, fid) = iprot.readFieldBegin()
17656 
      if ftype == TType.STOP:
17657 
        break
17658 
      if fid == 0:
17659 
        if ftype == TType.BOOL:
17660 
          self.success = iprot.readBool();
17661 
        else:
17662 
          iprot.skip(ftype)
17663 
      elif fid == 1:
17664 
        if ftype == TType.STRUCT:
17665 
          self.cex = CatalogServiceException()
17666 
          self.cex.read(iprot)
17667 
        else:
17668 
          iprot.skip(ftype)
17669 
      else:
17670 
        iprot.skip(ftype)
17671 
      iprot.readFieldEnd()
17672 
    iprot.readStructEnd()
17673 
 
17674 
  def write(self, oprot):
17675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17677 
      return
17678 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17679 
    if self.success is not None:
17680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17681 
      oprot.writeBool(self.success)
17682 
      oprot.writeFieldEnd()
17683 
    if self.cex is not None:
17684 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17685 
      self.cex.write(oprot)
17686 
      oprot.writeFieldEnd()
17687 
    oprot.writeFieldStop()
17688 
    oprot.writeStructEnd()
17689 
 
17690 
  def validate(self):
17691 
    return
17692 
 
17693 
 
17694 
  def __repr__(self):
17695 
    L = ['%s=%r' % (key, value)
17696 
      for key, value in self.__dict__.iteritems()]
17697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17698 
 
17699 
  def __eq__(self, other):
17700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17701 
 
17702 
  def __ne__(self, other):
17703 
    return not (self == other)
17704 
 
17705 
class deleteVoucherForItem_args:
17706 
  """
17707 
  Attributes:
17708 
   - catalog_item_id
17709 
   - voucherType
17710 
  """
17711 
 
17712 
  thrift_spec = (
17713 
    None, # 0
17714 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17715 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17716 
  )
17717 
 
17718 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17719 
    self.catalog_item_id = catalog_item_id
17720 
    self.voucherType = voucherType
17721 
 
17722 
  def read(self, iprot):
17723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17725 
      return
17726 
    iprot.readStructBegin()
17727 
    while True:
17728 
      (fname, ftype, fid) = iprot.readFieldBegin()
17729 
      if ftype == TType.STOP:
17730 
        break
17731 
      if fid == 1:
17732 
        if ftype == TType.I64:
17733 
          self.catalog_item_id = iprot.readI64();
17734 
        else:
17735 
          iprot.skip(ftype)
17736 
      elif fid == 2:
17737 
        if ftype == TType.I64:
17738 
          self.voucherType = iprot.readI64();
17739 
        else:
17740 
          iprot.skip(ftype)
17741 
      else:
17742 
        iprot.skip(ftype)
17743 
      iprot.readFieldEnd()
17744 
    iprot.readStructEnd()
17745 
 
17746 
  def write(self, oprot):
17747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17749 
      return
17750 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17751 
    if self.catalog_item_id is not None:
17752 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17753 
      oprot.writeI64(self.catalog_item_id)
17754 
      oprot.writeFieldEnd()
17755 
    if self.voucherType is not None:
17756 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17757 
      oprot.writeI64(self.voucherType)
17758 
      oprot.writeFieldEnd()
17759 
    oprot.writeFieldStop()
17760 
    oprot.writeStructEnd()
17761 
 
17762 
  def validate(self):
17763 
    return
17764 
 
17765 
 
17766 
  def __repr__(self):
17767 
    L = ['%s=%r' % (key, value)
17768 
      for key, value in self.__dict__.iteritems()]
17769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17770 
 
17771 
  def __eq__(self, other):
17772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17773 
 
17774 
  def __ne__(self, other):
17775 
    return not (self == other)
17776 
 
17777 
class deleteVoucherForItem_result:
17778 
  """
17779 
  Attributes:
17780 
   - success
17781 
   - cex
17782 
  """
17783 
 
17784 
  thrift_spec = (
17785 
    (0, TType.BOOL, 'success', None, None, ), # 0
17786 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17787 
  )
17788 
 
17789 
  def __init__(self, success=None, cex=None,):
17790 
    self.success = success
17791 
    self.cex = cex
17792 
 
17793 
  def read(self, iprot):
17794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17796 
      return
17797 
    iprot.readStructBegin()
17798 
    while True:
17799 
      (fname, ftype, fid) = iprot.readFieldBegin()
17800 
      if ftype == TType.STOP:
17801 
        break
17802 
      if fid == 0:
17803 
        if ftype == TType.BOOL:
17804 
          self.success = iprot.readBool();
17805 
        else:
17806 
          iprot.skip(ftype)
17807 
      elif fid == 1:
17808 
        if ftype == TType.STRUCT:
17809 
          self.cex = CatalogServiceException()
17810 
          self.cex.read(iprot)
17811 
        else:
17812 
          iprot.skip(ftype)
17813 
      else:
17814 
        iprot.skip(ftype)
17815 
      iprot.readFieldEnd()
17816 
    iprot.readStructEnd()
17817 
 
17818 
  def write(self, oprot):
17819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17821 
      return
17822 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17823 
    if self.success is not None:
17824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17825 
      oprot.writeBool(self.success)
17826 
      oprot.writeFieldEnd()
17827 
    if self.cex is not None:
17828 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17829 
      self.cex.write(oprot)
17830 
      oprot.writeFieldEnd()
17831 
    oprot.writeFieldStop()
17832 
    oprot.writeStructEnd()
17833 
 
17834 
  def validate(self):
17835 
    return
17836 
 
17837 
 
17838 
  def __repr__(self):
17839 
    L = ['%s=%r' % (key, value)
17840 
      for key, value in self.__dict__.iteritems()]
17841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17842 
 
17843 
  def __eq__(self, other):
17844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17845 
 
17846 
  def __ne__(self, other):
17847 
    return not (self == other)
17848 
 
17849 
class getVoucherAmount_args:
17850 
  """
17851 
  Attributes:
17852 
   - itemId
17853 
   - voucherType
17854 
  """
17855 
 
17856 
  thrift_spec = (
17857 
    None, # 0
17858 
    (1, TType.I64, 'itemId', None, None, ), # 1
17859 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17860 
  )
17861 
 
17862 
  def __init__(self, itemId=None, voucherType=None,):
17863 
    self.itemId = itemId
17864 
    self.voucherType = voucherType
17865 
 
17866 
  def read(self, iprot):
17867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17869 
      return
17870 
    iprot.readStructBegin()
17871 
    while True:
17872 
      (fname, ftype, fid) = iprot.readFieldBegin()
17873 
      if ftype == TType.STOP:
17874 
        break
17875 
      if fid == 1:
17876 
        if ftype == TType.I64:
17877 
          self.itemId = iprot.readI64();
17878 
        else:
17879 
          iprot.skip(ftype)
17880 
      elif fid == 2:
17881 
        if ftype == TType.I64:
17882 
          self.voucherType = iprot.readI64();
17883 
        else:
17884 
          iprot.skip(ftype)
17885 
      else:
17886 
        iprot.skip(ftype)
17887 
      iprot.readFieldEnd()
17888 
    iprot.readStructEnd()
17889 
 
17890 
  def write(self, oprot):
17891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17893 
      return
17894 
    oprot.writeStructBegin('getVoucherAmount_args')
17895 
    if self.itemId is not None:
17896 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17897 
      oprot.writeI64(self.itemId)
17898 
      oprot.writeFieldEnd()
17899 
    if self.voucherType is not None:
17900 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17901 
      oprot.writeI64(self.voucherType)
17902 
      oprot.writeFieldEnd()
17903 
    oprot.writeFieldStop()
17904 
    oprot.writeStructEnd()
17905 
 
17906 
  def validate(self):
17907 
    return
17908 
 
17909 
 
17910 
  def __repr__(self):
17911 
    L = ['%s=%r' % (key, value)
17912 
      for key, value in self.__dict__.iteritems()]
17913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17914 
 
17915 
  def __eq__(self, other):
17916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17917 
 
17918 
  def __ne__(self, other):
17919 
    return not (self == other)
17920 
 
17921 
class getVoucherAmount_result:
17922 
  """
17923 
  Attributes:
17924 
   - success
17925 
  """
17926 
 
17927 
  thrift_spec = (
17928 
    (0, TType.I64, 'success', None, None, ), # 0
17929 
  )
17930 
 
17931 
  def __init__(self, success=None,):
17932 
    self.success = success
17933 
 
17934 
  def read(self, iprot):
17935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17937 
      return
17938 
    iprot.readStructBegin()
17939 
    while True:
17940 
      (fname, ftype, fid) = iprot.readFieldBegin()
17941 
      if ftype == TType.STOP:
17942 
        break
17943 
      if fid == 0:
17944 
        if ftype == TType.I64:
17945 
          self.success = iprot.readI64();
17946 
        else:
17947 
          iprot.skip(ftype)
17948 
      else:
17949 
        iprot.skip(ftype)
17950 
      iprot.readFieldEnd()
17951 
    iprot.readStructEnd()
17952 
 
17953 
  def write(self, oprot):
17954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17956 
      return
17957 
    oprot.writeStructBegin('getVoucherAmount_result')
17958 
    if self.success is not None:
17959 
      oprot.writeFieldBegin('success', TType.I64, 0)
17960 
      oprot.writeI64(self.success)
17961 
      oprot.writeFieldEnd()
17962 
    oprot.writeFieldStop()
17963 
    oprot.writeStructEnd()
17964 
 
17965 
  def validate(self):
17966 
    return
17967 
 
17968 
 
17969 
  def __repr__(self):
17970 
    L = ['%s=%r' % (key, value)
17971 
      for key, value in self.__dict__.iteritems()]
17972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17973 
 
17974 
  def __eq__(self, other):
17975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17976 
 
17977 
  def __ne__(self, other):
17978 
    return not (self == other)
17979 
 
17980 
class getAllItemVouchers_args:
17981 
  """
17982 
  Attributes:
17983 
   - itemId
17984 
  """
17985 
 
17986 
  thrift_spec = (
17987 
    None, # 0
17988 
    (1, TType.I64, 'itemId', None, None, ), # 1
17989 
  )
17990 
 
17991 
  def __init__(self, itemId=None,):
17992 
    self.itemId = itemId
17993 
 
17994 
  def read(self, iprot):
17995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17997 
      return
17998 
    iprot.readStructBegin()
17999 
    while True:
18000 
      (fname, ftype, fid) = iprot.readFieldBegin()
18001 
      if ftype == TType.STOP:
18002 
        break
18003 
      if fid == 1:
18004 
        if ftype == TType.I64:
18005 
          self.itemId = iprot.readI64();
18006 
        else:
18007 
          iprot.skip(ftype)
18008 
      else:
18009 
        iprot.skip(ftype)
18010 
      iprot.readFieldEnd()
18011 
    iprot.readStructEnd()
18012 
 
18013 
  def write(self, oprot):
18014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18016 
      return
18017 
    oprot.writeStructBegin('getAllItemVouchers_args')
18018 
    if self.itemId is not None:
18019 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18020 
      oprot.writeI64(self.itemId)
18021 
      oprot.writeFieldEnd()
18022 
    oprot.writeFieldStop()
18023 
    oprot.writeStructEnd()
18024 
 
18025 
  def validate(self):
18026 
    return
18027 
 
18028 
 
18029 
  def __repr__(self):
18030 
    L = ['%s=%r' % (key, value)
18031 
      for key, value in self.__dict__.iteritems()]
18032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18033 
 
18034 
  def __eq__(self, other):
18035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18036 
 
18037 
  def __ne__(self, other):
18038 
    return not (self == other)
18039 
 
18040 
class getAllItemVouchers_result:
18041 
  """
18042 
  Attributes:
18043 
   - success
18044 
  """
18045 
 
18046 
  thrift_spec = (
18047 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18048 
  )
18049 
 
18050 
  def __init__(self, success=None,):
18051 
    self.success = success
18052 
 
18053 
  def read(self, iprot):
18054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18056 
      return
18057 
    iprot.readStructBegin()
18058 
    while True:
18059 
      (fname, ftype, fid) = iprot.readFieldBegin()
18060 
      if ftype == TType.STOP:
18061 
        break
18062 
      if fid == 0:
18063 
        if ftype == TType.LIST:
18064 
          self.success = []
9155 kshitij.so 18065 
          (_etype363, _size360) = iprot.readListBegin()
18066 
          for _i364 in xrange(_size360):
18067 
            _elem365 = VoucherItemMapping()
18068 
            _elem365.read(iprot)
18069 
            self.success.append(_elem365)
5944 mandeep.dh 18070 
          iprot.readListEnd()
18071 
        else:
18072 
          iprot.skip(ftype)
18073 
      else:
18074 
        iprot.skip(ftype)
18075 
      iprot.readFieldEnd()
18076 
    iprot.readStructEnd()
18077 
 
18078 
  def write(self, oprot):
18079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18081 
      return
18082 
    oprot.writeStructBegin('getAllItemVouchers_result')
18083 
    if self.success is not None:
18084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18085 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18086 
      for iter366 in self.success:
18087 
        iter366.write(oprot)
5944 mandeep.dh 18088 
      oprot.writeListEnd()
18089 
      oprot.writeFieldEnd()
18090 
    oprot.writeFieldStop()
18091 
    oprot.writeStructEnd()
18092 
 
18093 
  def validate(self):
18094 
    return
18095 
 
18096 
 
18097 
  def __repr__(self):
18098 
    L = ['%s=%r' % (key, value)
18099 
      for key, value in self.__dict__.iteritems()]
18100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18101 
 
18102 
  def __eq__(self, other):
18103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18104 
 
18105 
  def __ne__(self, other):
18106 
    return not (self == other)
18107 
 
18108 
class isValidCatalogItemId_args:
18109 
  """
18110 
  Attributes:
18111 
   - catalog_item_id
18112 
  """
18113 
 
18114 
  thrift_spec = (
18115 
    None, # 0
18116 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18117 
  )
18118 
 
18119 
  def __init__(self, catalog_item_id=None,):
18120 
    self.catalog_item_id = catalog_item_id
18121 
 
18122 
  def read(self, iprot):
18123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18125 
      return
18126 
    iprot.readStructBegin()
18127 
    while True:
18128 
      (fname, ftype, fid) = iprot.readFieldBegin()
18129 
      if ftype == TType.STOP:
18130 
        break
18131 
      if fid == 1:
18132 
        if ftype == TType.I64:
18133 
          self.catalog_item_id = iprot.readI64();
18134 
        else:
18135 
          iprot.skip(ftype)
18136 
      else:
18137 
        iprot.skip(ftype)
18138 
      iprot.readFieldEnd()
18139 
    iprot.readStructEnd()
18140 
 
18141 
  def write(self, oprot):
18142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18144 
      return
18145 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18146 
    if self.catalog_item_id is not None:
18147 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18148 
      oprot.writeI64(self.catalog_item_id)
18149 
      oprot.writeFieldEnd()
18150 
    oprot.writeFieldStop()
18151 
    oprot.writeStructEnd()
18152 
 
18153 
  def validate(self):
18154 
    return
18155 
 
18156 
 
18157 
  def __repr__(self):
18158 
    L = ['%s=%r' % (key, value)
18159 
      for key, value in self.__dict__.iteritems()]
18160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18161 
 
18162 
  def __eq__(self, other):
18163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18164 
 
18165 
  def __ne__(self, other):
18166 
    return not (self == other)
18167 
 
18168 
class isValidCatalogItemId_result:
18169 
  """
18170 
  Attributes:
18171 
   - success
18172 
  """
18173 
 
18174 
  thrift_spec = (
18175 
    (0, TType.BOOL, 'success', None, None, ), # 0
18176 
  )
18177 
 
18178 
  def __init__(self, success=None,):
18179 
    self.success = success
18180 
 
18181 
  def read(self, iprot):
18182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18184 
      return
18185 
    iprot.readStructBegin()
18186 
    while True:
18187 
      (fname, ftype, fid) = iprot.readFieldBegin()
18188 
      if ftype == TType.STOP:
18189 
        break
18190 
      if fid == 0:
18191 
        if ftype == TType.BOOL:
18192 
          self.success = iprot.readBool();
18193 
        else:
18194 
          iprot.skip(ftype)
18195 
      else:
18196 
        iprot.skip(ftype)
18197 
      iprot.readFieldEnd()
18198 
    iprot.readStructEnd()
18199 
 
18200 
  def write(self, oprot):
18201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18203 
      return
18204 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18205 
    if self.success is not None:
18206 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18207 
      oprot.writeBool(self.success)
18208 
      oprot.writeFieldEnd()
18209 
    oprot.writeFieldStop()
18210 
    oprot.writeStructEnd()
18211 
 
18212 
  def validate(self):
18213 
    return
18214 
 
18215 
 
18216 
  def __repr__(self):
18217 
    L = ['%s=%r' % (key, value)
18218 
      for key, value in self.__dict__.iteritems()]
18219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18220 
 
18221 
  def __eq__(self, other):
18222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18223 
 
18224 
  def __ne__(self, other):
18225 
    return not (self == other)
6039 amit.gupta 18226 
 
18227 
class getVatPercentageForItem_args:
18228 
  """
18229 
  Attributes:
18230 
   - itemId
7330 amit.gupta 18231 
   - stateId
6039 amit.gupta 18232 
   - price
18233 
  """
18234 
 
18235 
  thrift_spec = (
18236 
    None, # 0
18237 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18238 
    (2, TType.I64, 'stateId', None, None, ), # 2
18239 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18240 
  )
18241 
 
7330 amit.gupta 18242 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18243 
    self.itemId = itemId
7330 amit.gupta 18244 
    self.stateId = stateId
6039 amit.gupta 18245 
    self.price = price
18246 
 
18247 
  def read(self, iprot):
18248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18250 
      return
18251 
    iprot.readStructBegin()
18252 
    while True:
18253 
      (fname, ftype, fid) = iprot.readFieldBegin()
18254 
      if ftype == TType.STOP:
18255 
        break
18256 
      if fid == 1:
18257 
        if ftype == TType.I64:
18258 
          self.itemId = iprot.readI64();
18259 
        else:
18260 
          iprot.skip(ftype)
18261 
      elif fid == 2:
7330 amit.gupta 18262 
        if ftype == TType.I64:
18263 
          self.stateId = iprot.readI64();
18264 
        else:
18265 
          iprot.skip(ftype)
18266 
      elif fid == 3:
6039 amit.gupta 18267 
        if ftype == TType.DOUBLE:
18268 
          self.price = iprot.readDouble();
18269 
        else:
18270 
          iprot.skip(ftype)
18271 
      else:
18272 
        iprot.skip(ftype)
18273 
      iprot.readFieldEnd()
18274 
    iprot.readStructEnd()
18275 
 
18276 
  def write(self, oprot):
18277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18279 
      return
18280 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18281 
    if self.itemId is not None:
18282 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18283 
      oprot.writeI64(self.itemId)
18284 
      oprot.writeFieldEnd()
7330 amit.gupta 18285 
    if self.stateId is not None:
18286 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18287 
      oprot.writeI64(self.stateId)
18288 
      oprot.writeFieldEnd()
6039 amit.gupta 18289 
    if self.price is not None:
7330 amit.gupta 18290 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18291 
      oprot.writeDouble(self.price)
18292 
      oprot.writeFieldEnd()
18293 
    oprot.writeFieldStop()
18294 
    oprot.writeStructEnd()
18295 
 
18296 
  def validate(self):
18297 
    return
18298 
 
18299 
 
18300 
  def __repr__(self):
18301 
    L = ['%s=%r' % (key, value)
18302 
      for key, value in self.__dict__.iteritems()]
18303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18304 
 
18305 
  def __eq__(self, other):
18306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18307 
 
18308 
  def __ne__(self, other):
18309 
    return not (self == other)
18310 
 
18311 
class getVatPercentageForItem_result:
18312 
  """
18313 
  Attributes:
18314 
   - success
7340 amit.gupta 18315 
   - cex
6039 amit.gupta 18316 
  """
18317 
 
18318 
  thrift_spec = (
18319 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18320 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18321 
  )
18322 
 
7340 amit.gupta 18323 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18324 
    self.success = success
7340 amit.gupta 18325 
    self.cex = cex
6039 amit.gupta 18326 
 
18327 
  def read(self, iprot):
18328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18330 
      return
18331 
    iprot.readStructBegin()
18332 
    while True:
18333 
      (fname, ftype, fid) = iprot.readFieldBegin()
18334 
      if ftype == TType.STOP:
18335 
        break
18336 
      if fid == 0:
18337 
        if ftype == TType.DOUBLE:
18338 
          self.success = iprot.readDouble();
18339 
        else:
18340 
          iprot.skip(ftype)
7340 amit.gupta 18341 
      elif fid == 1:
18342 
        if ftype == TType.STRUCT:
18343 
          self.cex = CatalogServiceException()
18344 
          self.cex.read(iprot)
18345 
        else:
18346 
          iprot.skip(ftype)
6039 amit.gupta 18347 
      else:
18348 
        iprot.skip(ftype)
18349 
      iprot.readFieldEnd()
18350 
    iprot.readStructEnd()
18351 
 
18352 
  def write(self, oprot):
18353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18355 
      return
18356 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18357 
    if self.success is not None:
18358 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18359 
      oprot.writeDouble(self.success)
18360 
      oprot.writeFieldEnd()
7340 amit.gupta 18361 
    if self.cex is not None:
18362 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18363 
      self.cex.write(oprot)
18364 
      oprot.writeFieldEnd()
6039 amit.gupta 18365 
    oprot.writeFieldStop()
18366 
    oprot.writeStructEnd()
18367 
 
18368 
  def validate(self):
18369 
    return
18370 
 
18371 
 
18372 
  def __repr__(self):
18373 
    L = ['%s=%r' % (key, value)
18374 
      for key, value in self.__dict__.iteritems()]
18375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18376 
 
18377 
  def __eq__(self, other):
18378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18379 
 
18380 
  def __ne__(self, other):
18381 
    return not (self == other)
18382 
 
18383 
class getVatAmountForItem_args:
18384 
  """
18385 
  Attributes:
18386 
   - itemId
18387 
   - price
18388 
  """
18389 
 
18390 
  thrift_spec = (
18391 
    None, # 0
18392 
    (1, TType.I64, 'itemId', None, None, ), # 1
18393 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18394 
  )
18395 
 
18396 
  def __init__(self, itemId=None, price=None,):
18397 
    self.itemId = itemId
18398 
    self.price = price
18399 
 
18400 
  def read(self, iprot):
18401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18403 
      return
18404 
    iprot.readStructBegin()
18405 
    while True:
18406 
      (fname, ftype, fid) = iprot.readFieldBegin()
18407 
      if ftype == TType.STOP:
18408 
        break
18409 
      if fid == 1:
18410 
        if ftype == TType.I64:
18411 
          self.itemId = iprot.readI64();
18412 
        else:
18413 
          iprot.skip(ftype)
18414 
      elif fid == 2:
18415 
        if ftype == TType.DOUBLE:
18416 
          self.price = iprot.readDouble();
18417 
        else:
18418 
          iprot.skip(ftype)
18419 
      else:
18420 
        iprot.skip(ftype)
18421 
      iprot.readFieldEnd()
18422 
    iprot.readStructEnd()
18423 
 
18424 
  def write(self, oprot):
18425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18427 
      return
18428 
    oprot.writeStructBegin('getVatAmountForItem_args')
18429 
    if self.itemId is not None:
18430 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18431 
      oprot.writeI64(self.itemId)
18432 
      oprot.writeFieldEnd()
18433 
    if self.price is not None:
18434 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18435 
      oprot.writeDouble(self.price)
18436 
      oprot.writeFieldEnd()
18437 
    oprot.writeFieldStop()
18438 
    oprot.writeStructEnd()
18439 
 
18440 
  def validate(self):
18441 
    return
18442 
 
18443 
 
18444 
  def __repr__(self):
18445 
    L = ['%s=%r' % (key, value)
18446 
      for key, value in self.__dict__.iteritems()]
18447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18448 
 
18449 
  def __eq__(self, other):
18450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18451 
 
18452 
  def __ne__(self, other):
18453 
    return not (self == other)
18454 
 
18455 
class getVatAmountForItem_result:
18456 
  """
18457 
  Attributes:
18458 
   - success
18459 
  """
18460 
 
18461 
  thrift_spec = (
18462 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18463 
  )
18464 
 
18465 
  def __init__(self, success=None,):
18466 
    self.success = success
18467 
 
18468 
  def read(self, iprot):
18469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18471 
      return
18472 
    iprot.readStructBegin()
18473 
    while True:
18474 
      (fname, ftype, fid) = iprot.readFieldBegin()
18475 
      if ftype == TType.STOP:
18476 
        break
18477 
      if fid == 0:
18478 
        if ftype == TType.DOUBLE:
18479 
          self.success = iprot.readDouble();
18480 
        else:
18481 
          iprot.skip(ftype)
18482 
      else:
18483 
        iprot.skip(ftype)
18484 
      iprot.readFieldEnd()
18485 
    iprot.readStructEnd()
18486 
 
18487 
  def write(self, oprot):
18488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18490 
      return
18491 
    oprot.writeStructBegin('getVatAmountForItem_result')
18492 
    if self.success is not None:
18493 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18494 
      oprot.writeDouble(self.success)
18495 
      oprot.writeFieldEnd()
18496 
    oprot.writeFieldStop()
18497 
    oprot.writeStructEnd()
18498 
 
18499 
  def validate(self):
18500 
    return
18501 
 
18502 
 
18503 
  def __repr__(self):
18504 
    L = ['%s=%r' % (key, value)
18505 
      for key, value in self.__dict__.iteritems()]
18506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18507 
 
18508 
  def __eq__(self, other):
18509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18510 
 
18511 
  def __ne__(self, other):
18512 
    return not (self == other)
6531 vikram.rag 18513 
 
18514 
class getAllIgnoredInventoryUpdateItemsList_args:
18515 
  """
18516 
  Attributes:
18517 
   - offset
18518 
   - limit
18519 
  """
18520 
 
18521 
  thrift_spec = (
18522 
    None, # 0
18523 
    (1, TType.I32, 'offset', None, None, ), # 1
18524 
    (2, TType.I32, 'limit', None, None, ), # 2
18525 
  )
18526 
 
18527 
  def __init__(self, offset=None, limit=None,):
18528 
    self.offset = offset
18529 
    self.limit = limit
18530 
 
18531 
  def read(self, iprot):
18532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18534 
      return
18535 
    iprot.readStructBegin()
18536 
    while True:
18537 
      (fname, ftype, fid) = iprot.readFieldBegin()
18538 
      if ftype == TType.STOP:
18539 
        break
18540 
      if fid == 1:
18541 
        if ftype == TType.I32:
18542 
          self.offset = iprot.readI32();
18543 
        else:
18544 
          iprot.skip(ftype)
18545 
      elif fid == 2:
18546 
        if ftype == TType.I32:
18547 
          self.limit = iprot.readI32();
18548 
        else:
18549 
          iprot.skip(ftype)
18550 
      else:
18551 
        iprot.skip(ftype)
18552 
      iprot.readFieldEnd()
18553 
    iprot.readStructEnd()
18554 
 
18555 
  def write(self, oprot):
18556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18558 
      return
18559 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18560 
    if self.offset is not None:
18561 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18562 
      oprot.writeI32(self.offset)
18563 
      oprot.writeFieldEnd()
18564 
    if self.limit is not None:
18565 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18566 
      oprot.writeI32(self.limit)
18567 
      oprot.writeFieldEnd()
18568 
    oprot.writeFieldStop()
18569 
    oprot.writeStructEnd()
18570 
 
18571 
  def validate(self):
18572 
    return
18573 
 
18574 
 
18575 
  def __repr__(self):
18576 
    L = ['%s=%r' % (key, value)
18577 
      for key, value in self.__dict__.iteritems()]
18578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18579 
 
18580 
  def __eq__(self, other):
18581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18582 
 
18583 
  def __ne__(self, other):
18584 
    return not (self == other)
18585 
 
18586 
class getAllIgnoredInventoryUpdateItemsList_result:
18587 
  """
18588 
  Attributes:
18589 
   - success
18590 
  """
18591 
 
18592 
  thrift_spec = (
18593 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18594 
  )
18595 
 
18596 
  def __init__(self, success=None,):
18597 
    self.success = success
18598 
 
18599 
  def read(self, iprot):
18600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18602 
      return
18603 
    iprot.readStructBegin()
18604 
    while True:
18605 
      (fname, ftype, fid) = iprot.readFieldBegin()
18606 
      if ftype == TType.STOP:
18607 
        break
18608 
      if fid == 0:
18609 
        if ftype == TType.LIST:
18610 
          self.success = []
9155 kshitij.so 18611 
          (_etype370, _size367) = iprot.readListBegin()
18612 
          for _i371 in xrange(_size367):
18613 
            _elem372 = Item()
18614 
            _elem372.read(iprot)
18615 
            self.success.append(_elem372)
6531 vikram.rag 18616 
          iprot.readListEnd()
18617 
        else:
18618 
          iprot.skip(ftype)
18619 
      else:
18620 
        iprot.skip(ftype)
18621 
      iprot.readFieldEnd()
18622 
    iprot.readStructEnd()
18623 
 
18624 
  def write(self, oprot):
18625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18627 
      return
18628 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18629 
    if self.success is not None:
18630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18631 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18632 
      for iter373 in self.success:
18633 
        iter373.write(oprot)
6531 vikram.rag 18634 
      oprot.writeListEnd()
18635 
      oprot.writeFieldEnd()
18636 
    oprot.writeFieldStop()
18637 
    oprot.writeStructEnd()
18638 
 
18639 
  def validate(self):
18640 
    return
18641 
 
18642 
 
18643 
  def __repr__(self):
18644 
    L = ['%s=%r' % (key, value)
18645 
      for key, value in self.__dict__.iteritems()]
18646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18647 
 
18648 
  def __eq__(self, other):
18649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18650 
 
18651 
  def __ne__(self, other):
18652 
    return not (self == other)
6805 anupam.sin 18653 
 
6821 amar.kumar 18654 
class getAllAliveItems_args:
18655 
 
18656 
  thrift_spec = (
18657 
  )
18658 
 
18659 
  def read(self, iprot):
18660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18662 
      return
18663 
    iprot.readStructBegin()
18664 
    while True:
18665 
      (fname, ftype, fid) = iprot.readFieldBegin()
18666 
      if ftype == TType.STOP:
18667 
        break
18668 
      else:
18669 
        iprot.skip(ftype)
18670 
      iprot.readFieldEnd()
18671 
    iprot.readStructEnd()
18672 
 
18673 
  def write(self, oprot):
18674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18676 
      return
18677 
    oprot.writeStructBegin('getAllAliveItems_args')
18678 
    oprot.writeFieldStop()
18679 
    oprot.writeStructEnd()
18680 
 
18681 
  def validate(self):
18682 
    return
18683 
 
18684 
 
18685 
  def __repr__(self):
18686 
    L = ['%s=%r' % (key, value)
18687 
      for key, value in self.__dict__.iteritems()]
18688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18689 
 
18690 
  def __eq__(self, other):
18691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18692 
 
18693 
  def __ne__(self, other):
18694 
    return not (self == other)
18695 
 
18696 
class getAllAliveItems_result:
18697 
  """
18698 
  Attributes:
18699 
   - success
18700 
  """
18701 
 
18702 
  thrift_spec = (
18703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18704 
  )
18705 
 
18706 
  def __init__(self, success=None,):
18707 
    self.success = success
18708 
 
18709 
  def read(self, iprot):
18710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18712 
      return
18713 
    iprot.readStructBegin()
18714 
    while True:
18715 
      (fname, ftype, fid) = iprot.readFieldBegin()
18716 
      if ftype == TType.STOP:
18717 
        break
18718 
      if fid == 0:
18719 
        if ftype == TType.LIST:
18720 
          self.success = []
9155 kshitij.so 18721 
          (_etype377, _size374) = iprot.readListBegin()
18722 
          for _i378 in xrange(_size374):
18723 
            _elem379 = Item()
18724 
            _elem379.read(iprot)
18725 
            self.success.append(_elem379)
6821 amar.kumar 18726 
          iprot.readListEnd()
18727 
        else:
18728 
          iprot.skip(ftype)
18729 
      else:
18730 
        iprot.skip(ftype)
18731 
      iprot.readFieldEnd()
18732 
    iprot.readStructEnd()
18733 
 
18734 
  def write(self, oprot):
18735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18737 
      return
18738 
    oprot.writeStructBegin('getAllAliveItems_result')
18739 
    if self.success is not None:
18740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18742 
      for iter380 in self.success:
18743 
        iter380.write(oprot)
6821 amar.kumar 18744 
      oprot.writeListEnd()
18745 
      oprot.writeFieldEnd()
18746 
    oprot.writeFieldStop()
18747 
    oprot.writeStructEnd()
18748 
 
18749 
  def validate(self):
18750 
    return
18751 
 
18752 
 
18753 
  def __repr__(self):
18754 
    L = ['%s=%r' % (key, value)
18755 
      for key, value in self.__dict__.iteritems()]
18756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18757 
 
18758 
  def __eq__(self, other):
18759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18760 
 
18761 
  def __ne__(self, other):
18762 
    return not (self == other)
18763 
 
6805 anupam.sin 18764 
class getInsuranceAmount_args:
18765 
  """
18766 
  Attributes:
18767 
   - itemId
6921 anupam.sin 18768 
   - price
6805 anupam.sin 18769 
   - insurerId
18770 
   - quantity
18771 
  """
18772 
 
18773 
  thrift_spec = (
18774 
    None, # 0
18775 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18776 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18777 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18778 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18779 
  )
18780 
 
6921 anupam.sin 18781 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18782 
    self.itemId = itemId
6921 anupam.sin 18783 
    self.price = price
6805 anupam.sin 18784 
    self.insurerId = insurerId
18785 
    self.quantity = quantity
18786 
 
18787 
  def read(self, iprot):
18788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18790 
      return
18791 
    iprot.readStructBegin()
18792 
    while True:
18793 
      (fname, ftype, fid) = iprot.readFieldBegin()
18794 
      if ftype == TType.STOP:
18795 
        break
18796 
      if fid == 1:
18797 
        if ftype == TType.I64:
18798 
          self.itemId = iprot.readI64();
18799 
        else:
18800 
          iprot.skip(ftype)
18801 
      elif fid == 2:
6921 anupam.sin 18802 
        if ftype == TType.DOUBLE:
18803 
          self.price = iprot.readDouble();
18804 
        else:
18805 
          iprot.skip(ftype)
18806 
      elif fid == 3:
6805 anupam.sin 18807 
        if ftype == TType.I64:
18808 
          self.insurerId = iprot.readI64();
18809 
        else:
18810 
          iprot.skip(ftype)
6921 anupam.sin 18811 
      elif fid == 4:
6805 anupam.sin 18812 
        if ftype == TType.I64:
18813 
          self.quantity = iprot.readI64();
18814 
        else:
18815 
          iprot.skip(ftype)
18816 
      else:
18817 
        iprot.skip(ftype)
18818 
      iprot.readFieldEnd()
18819 
    iprot.readStructEnd()
18820 
 
18821 
  def write(self, oprot):
18822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18824 
      return
18825 
    oprot.writeStructBegin('getInsuranceAmount_args')
18826 
    if self.itemId is not None:
18827 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18828 
      oprot.writeI64(self.itemId)
18829 
      oprot.writeFieldEnd()
6921 anupam.sin 18830 
    if self.price is not None:
18831 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18832 
      oprot.writeDouble(self.price)
18833 
      oprot.writeFieldEnd()
6805 anupam.sin 18834 
    if self.insurerId is not None:
6921 anupam.sin 18835 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18836 
      oprot.writeI64(self.insurerId)
18837 
      oprot.writeFieldEnd()
18838 
    if self.quantity is not None:
6921 anupam.sin 18839 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18840 
      oprot.writeI64(self.quantity)
18841 
      oprot.writeFieldEnd()
18842 
    oprot.writeFieldStop()
18843 
    oprot.writeStructEnd()
18844 
 
18845 
  def validate(self):
18846 
    return
18847 
 
18848 
 
18849 
  def __repr__(self):
18850 
    L = ['%s=%r' % (key, value)
18851 
      for key, value in self.__dict__.iteritems()]
18852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18853 
 
18854 
  def __eq__(self, other):
18855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18856 
 
18857 
  def __ne__(self, other):
18858 
    return not (self == other)
18859 
 
18860 
class getInsuranceAmount_result:
18861 
  """
18862 
  Attributes:
18863 
   - success
18864 
  """
18865 
 
18866 
  thrift_spec = (
18867 
    (0, TType.I64, 'success', None, None, ), # 0
18868 
  )
18869 
 
18870 
  def __init__(self, success=None,):
18871 
    self.success = success
18872 
 
18873 
  def read(self, iprot):
18874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18876 
      return
18877 
    iprot.readStructBegin()
18878 
    while True:
18879 
      (fname, ftype, fid) = iprot.readFieldBegin()
18880 
      if ftype == TType.STOP:
18881 
        break
18882 
      if fid == 0:
18883 
        if ftype == TType.I64:
18884 
          self.success = iprot.readI64();
18885 
        else:
18886 
          iprot.skip(ftype)
18887 
      else:
18888 
        iprot.skip(ftype)
18889 
      iprot.readFieldEnd()
18890 
    iprot.readStructEnd()
18891 
 
18892 
  def write(self, oprot):
18893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18895 
      return
18896 
    oprot.writeStructBegin('getInsuranceAmount_result')
18897 
    if self.success is not None:
18898 
      oprot.writeFieldBegin('success', TType.I64, 0)
18899 
      oprot.writeI64(self.success)
18900 
      oprot.writeFieldEnd()
18901 
    oprot.writeFieldStop()
18902 
    oprot.writeStructEnd()
18903 
 
18904 
  def validate(self):
18905 
    return
18906 
 
18907 
 
18908 
  def __repr__(self):
18909 
    L = ['%s=%r' % (key, value)
18910 
      for key, value in self.__dict__.iteritems()]
18911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18912 
 
18913 
  def __eq__(self, other):
18914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18915 
 
18916 
  def __ne__(self, other):
18917 
    return not (self == other)
18918 
 
18919 
class getInsurer_args:
18920 
  """
18921 
  Attributes:
18922 
   - insurerId
18923 
  """
18924 
 
18925 
  thrift_spec = (
18926 
    None, # 0
18927 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18928 
  )
18929 
 
18930 
  def __init__(self, insurerId=None,):
18931 
    self.insurerId = insurerId
18932 
 
18933 
  def read(self, iprot):
18934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18936 
      return
18937 
    iprot.readStructBegin()
18938 
    while True:
18939 
      (fname, ftype, fid) = iprot.readFieldBegin()
18940 
      if ftype == TType.STOP:
18941 
        break
18942 
      if fid == 1:
18943 
        if ftype == TType.I64:
18944 
          self.insurerId = iprot.readI64();
18945 
        else:
18946 
          iprot.skip(ftype)
18947 
      else:
18948 
        iprot.skip(ftype)
18949 
      iprot.readFieldEnd()
18950 
    iprot.readStructEnd()
18951 
 
18952 
  def write(self, oprot):
18953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18955 
      return
18956 
    oprot.writeStructBegin('getInsurer_args')
18957 
    if self.insurerId is not None:
18958 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18959 
      oprot.writeI64(self.insurerId)
18960 
      oprot.writeFieldEnd()
18961 
    oprot.writeFieldStop()
18962 
    oprot.writeStructEnd()
18963 
 
18964 
  def validate(self):
18965 
    return
18966 
 
18967 
 
18968 
  def __repr__(self):
18969 
    L = ['%s=%r' % (key, value)
18970 
      for key, value in self.__dict__.iteritems()]
18971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18972 
 
18973 
  def __eq__(self, other):
18974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18975 
 
18976 
  def __ne__(self, other):
18977 
    return not (self == other)
18978 
 
18979 
class getInsurer_result:
18980 
  """
18981 
  Attributes:
18982 
   - success
18983 
  """
18984 
 
18985 
  thrift_spec = (
18986 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18987 
  )
18988 
 
18989 
  def __init__(self, success=None,):
18990 
    self.success = success
18991 
 
18992 
  def read(self, iprot):
18993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18995 
      return
18996 
    iprot.readStructBegin()
18997 
    while True:
18998 
      (fname, ftype, fid) = iprot.readFieldBegin()
18999 
      if ftype == TType.STOP:
19000 
        break
19001 
      if fid == 0:
19002 
        if ftype == TType.STRUCT:
19003 
          self.success = Insurer()
19004 
          self.success.read(iprot)
19005 
        else:
19006 
          iprot.skip(ftype)
19007 
      else:
19008 
        iprot.skip(ftype)
19009 
      iprot.readFieldEnd()
19010 
    iprot.readStructEnd()
19011 
 
19012 
  def write(self, oprot):
19013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19015 
      return
19016 
    oprot.writeStructBegin('getInsurer_result')
19017 
    if self.success is not None:
19018 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19019 
      self.success.write(oprot)
19020 
      oprot.writeFieldEnd()
19021 
    oprot.writeFieldStop()
19022 
    oprot.writeStructEnd()
19023 
 
19024 
  def validate(self):
19025 
    return
19026 
 
19027 
 
19028 
  def __repr__(self):
19029 
    L = ['%s=%r' % (key, value)
19030 
      for key, value in self.__dict__.iteritems()]
19031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19032 
 
19033 
  def __eq__(self, other):
19034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19035 
 
19036 
  def __ne__(self, other):
19037 
    return not (self == other)
6838 vikram.rag 19038 
 
19039 
class getAllInsurers_args:
19040 
 
19041 
  thrift_spec = (
19042 
  )
19043 
 
19044 
  def read(self, iprot):
19045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19047 
      return
19048 
    iprot.readStructBegin()
19049 
    while True:
19050 
      (fname, ftype, fid) = iprot.readFieldBegin()
19051 
      if ftype == TType.STOP:
19052 
        break
19053 
      else:
19054 
        iprot.skip(ftype)
19055 
      iprot.readFieldEnd()
19056 
    iprot.readStructEnd()
19057 
 
19058 
  def write(self, oprot):
19059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19061 
      return
19062 
    oprot.writeStructBegin('getAllInsurers_args')
19063 
    oprot.writeFieldStop()
19064 
    oprot.writeStructEnd()
19065 
 
19066 
  def validate(self):
19067 
    return
19068 
 
19069 
 
19070 
  def __repr__(self):
19071 
    L = ['%s=%r' % (key, value)
19072 
      for key, value in self.__dict__.iteritems()]
19073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19074 
 
19075 
  def __eq__(self, other):
19076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19077 
 
19078 
  def __ne__(self, other):
19079 
    return not (self == other)
19080 
 
19081 
class getAllInsurers_result:
19082 
  """
19083 
  Attributes:
19084 
   - success
19085 
  """
19086 
 
19087 
  thrift_spec = (
19088 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19089 
  )
19090 
 
19091 
  def __init__(self, success=None,):
19092 
    self.success = success
19093 
 
19094 
  def read(self, iprot):
19095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19097 
      return
19098 
    iprot.readStructBegin()
19099 
    while True:
19100 
      (fname, ftype, fid) = iprot.readFieldBegin()
19101 
      if ftype == TType.STOP:
19102 
        break
19103 
      if fid == 0:
19104 
        if ftype == TType.LIST:
19105 
          self.success = []
9155 kshitij.so 19106 
          (_etype384, _size381) = iprot.readListBegin()
19107 
          for _i385 in xrange(_size381):
19108 
            _elem386 = Insurer()
19109 
            _elem386.read(iprot)
19110 
            self.success.append(_elem386)
6838 vikram.rag 19111 
          iprot.readListEnd()
19112 
        else:
19113 
          iprot.skip(ftype)
19114 
      else:
19115 
        iprot.skip(ftype)
19116 
      iprot.readFieldEnd()
19117 
    iprot.readStructEnd()
19118 
 
19119 
  def write(self, oprot):
19120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19122 
      return
19123 
    oprot.writeStructBegin('getAllInsurers_result')
19124 
    if self.success is not None:
19125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19127 
      for iter387 in self.success:
19128 
        iter387.write(oprot)
6838 vikram.rag 19129 
      oprot.writeListEnd()
19130 
      oprot.writeFieldEnd()
19131 
    oprot.writeFieldStop()
19132 
    oprot.writeStructEnd()
19133 
 
19134 
  def validate(self):
19135 
    return
19136 
 
19137 
 
19138 
  def __repr__(self):
19139 
    L = ['%s=%r' % (key, value)
19140 
      for key, value in self.__dict__.iteritems()]
19141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19142 
 
19143 
  def __eq__(self, other):
19144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19145 
 
19146 
  def __ne__(self, other):
19147 
    return not (self == other)
6962 rajveer 19148 
 
19149 
class updateInsuranceDeclaredAmount_args:
19150 
  """
19151 
  Attributes:
19152 
   - insurerId
19153 
   - amount
19154 
  """
19155 
 
19156 
  thrift_spec = (
19157 
    None, # 0
19158 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19159 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19160 
  )
19161 
 
19162 
  def __init__(self, insurerId=None, amount=None,):
19163 
    self.insurerId = insurerId
19164 
    self.amount = amount
19165 
 
19166 
  def read(self, iprot):
19167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19169 
      return
19170 
    iprot.readStructBegin()
19171 
    while True:
19172 
      (fname, ftype, fid) = iprot.readFieldBegin()
19173 
      if ftype == TType.STOP:
19174 
        break
19175 
      if fid == 1:
19176 
        if ftype == TType.I64:
19177 
          self.insurerId = iprot.readI64();
19178 
        else:
19179 
          iprot.skip(ftype)
19180 
      elif fid == 2:
19181 
        if ftype == TType.DOUBLE:
19182 
          self.amount = iprot.readDouble();
19183 
        else:
19184 
          iprot.skip(ftype)
19185 
      else:
19186 
        iprot.skip(ftype)
19187 
      iprot.readFieldEnd()
19188 
    iprot.readStructEnd()
19189 
 
19190 
  def write(self, oprot):
19191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19193 
      return
19194 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19195 
    if self.insurerId is not None:
19196 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19197 
      oprot.writeI64(self.insurerId)
19198 
      oprot.writeFieldEnd()
19199 
    if self.amount is not None:
19200 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19201 
      oprot.writeDouble(self.amount)
19202 
      oprot.writeFieldEnd()
19203 
    oprot.writeFieldStop()
19204 
    oprot.writeStructEnd()
19205 
 
19206 
  def validate(self):
19207 
    return
19208 
 
19209 
 
19210 
  def __repr__(self):
19211 
    L = ['%s=%r' % (key, value)
19212 
      for key, value in self.__dict__.iteritems()]
19213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19214 
 
19215 
  def __eq__(self, other):
19216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19217 
 
19218 
  def __ne__(self, other):
19219 
    return not (self == other)
19220 
 
19221 
class updateInsuranceDeclaredAmount_result:
19222 
 
19223 
  thrift_spec = (
19224 
  )
19225 
 
19226 
  def read(self, iprot):
19227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19229 
      return
19230 
    iprot.readStructBegin()
19231 
    while True:
19232 
      (fname, ftype, fid) = iprot.readFieldBegin()
19233 
      if ftype == TType.STOP:
19234 
        break
19235 
      else:
19236 
        iprot.skip(ftype)
19237 
      iprot.readFieldEnd()
19238 
    iprot.readStructEnd()
19239 
 
19240 
  def write(self, oprot):
19241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19243 
      return
19244 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19245 
    oprot.writeFieldStop()
19246 
    oprot.writeStructEnd()
19247 
 
19248 
  def validate(self):
19249 
    return
19250 
 
19251 
 
19252 
  def __repr__(self):
19253 
    L = ['%s=%r' % (key, value)
19254 
      for key, value in self.__dict__.iteritems()]
19255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19256 
 
19257 
  def __eq__(self, other):
19258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19259 
 
19260 
  def __ne__(self, other):
19261 
    return not (self == other)
7190 amar.kumar 19262 
 
19263 
class getFreebieForItem_args:
19264 
  """
19265 
  Attributes:
19266 
   - itemId
19267 
  """
19268 
 
19269 
  thrift_spec = (
19270 
    None, # 0
19271 
    (1, TType.I64, 'itemId', None, None, ), # 1
19272 
  )
19273 
 
19274 
  def __init__(self, itemId=None,):
19275 
    self.itemId = itemId
19276 
 
19277 
  def read(self, iprot):
19278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19280 
      return
19281 
    iprot.readStructBegin()
19282 
    while True:
19283 
      (fname, ftype, fid) = iprot.readFieldBegin()
19284 
      if ftype == TType.STOP:
19285 
        break
19286 
      if fid == 1:
19287 
        if ftype == TType.I64:
19288 
          self.itemId = iprot.readI64();
19289 
        else:
19290 
          iprot.skip(ftype)
19291 
      else:
19292 
        iprot.skip(ftype)
19293 
      iprot.readFieldEnd()
19294 
    iprot.readStructEnd()
19295 
 
19296 
  def write(self, oprot):
19297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19299 
      return
19300 
    oprot.writeStructBegin('getFreebieForItem_args')
19301 
    if self.itemId is not None:
19302 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19303 
      oprot.writeI64(self.itemId)
19304 
      oprot.writeFieldEnd()
19305 
    oprot.writeFieldStop()
19306 
    oprot.writeStructEnd()
19307 
 
19308 
  def validate(self):
19309 
    return
19310 
 
19311 
 
19312 
  def __repr__(self):
19313 
    L = ['%s=%r' % (key, value)
19314 
      for key, value in self.__dict__.iteritems()]
19315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19316 
 
19317 
  def __eq__(self, other):
19318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19319 
 
19320 
  def __ne__(self, other):
19321 
    return not (self == other)
19322 
 
19323 
class getFreebieForItem_result:
19324 
  """
19325 
  Attributes:
19326 
   - success
19327 
  """
19328 
 
19329 
  thrift_spec = (
19330 
    (0, TType.I64, 'success', None, None, ), # 0
19331 
  )
19332 
 
19333 
  def __init__(self, success=None,):
19334 
    self.success = success
19335 
 
19336 
  def read(self, iprot):
19337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19339 
      return
19340 
    iprot.readStructBegin()
19341 
    while True:
19342 
      (fname, ftype, fid) = iprot.readFieldBegin()
19343 
      if ftype == TType.STOP:
19344 
        break
19345 
      if fid == 0:
19346 
        if ftype == TType.I64:
19347 
          self.success = iprot.readI64();
19348 
        else:
19349 
          iprot.skip(ftype)
19350 
      else:
19351 
        iprot.skip(ftype)
19352 
      iprot.readFieldEnd()
19353 
    iprot.readStructEnd()
19354 
 
19355 
  def write(self, oprot):
19356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19358 
      return
19359 
    oprot.writeStructBegin('getFreebieForItem_result')
19360 
    if self.success is not None:
19361 
      oprot.writeFieldBegin('success', TType.I64, 0)
19362 
      oprot.writeI64(self.success)
19363 
      oprot.writeFieldEnd()
19364 
    oprot.writeFieldStop()
19365 
    oprot.writeStructEnd()
19366 
 
19367 
  def validate(self):
19368 
    return
19369 
 
19370 
 
19371 
  def __repr__(self):
19372 
    L = ['%s=%r' % (key, value)
19373 
      for key, value in self.__dict__.iteritems()]
19374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19375 
 
19376 
  def __eq__(self, other):
19377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19378 
 
19379 
  def __ne__(self, other):
19380 
    return not (self == other)
19381 
 
19382 
class addOrUpdateFreebieForItem_args:
19383 
  """
19384 
  Attributes:
19385 
   - freebieItem
19386 
  """
19387 
 
19388 
  thrift_spec = (
19389 
    None, # 0
19390 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19391 
  )
19392 
 
19393 
  def __init__(self, freebieItem=None,):
19394 
    self.freebieItem = freebieItem
19395 
 
19396 
  def read(self, iprot):
19397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19399 
      return
19400 
    iprot.readStructBegin()
19401 
    while True:
19402 
      (fname, ftype, fid) = iprot.readFieldBegin()
19403 
      if ftype == TType.STOP:
19404 
        break
19405 
      if fid == 1:
19406 
        if ftype == TType.STRUCT:
19407 
          self.freebieItem = FreebieItem()
19408 
          self.freebieItem.read(iprot)
19409 
        else:
19410 
          iprot.skip(ftype)
19411 
      else:
19412 
        iprot.skip(ftype)
19413 
      iprot.readFieldEnd()
19414 
    iprot.readStructEnd()
19415 
 
19416 
  def write(self, oprot):
19417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19419 
      return
19420 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19421 
    if self.freebieItem is not None:
19422 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19423 
      self.freebieItem.write(oprot)
19424 
      oprot.writeFieldEnd()
19425 
    oprot.writeFieldStop()
19426 
    oprot.writeStructEnd()
19427 
 
19428 
  def validate(self):
19429 
    return
19430 
 
19431 
 
19432 
  def __repr__(self):
19433 
    L = ['%s=%r' % (key, value)
19434 
      for key, value in self.__dict__.iteritems()]
19435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19436 
 
19437 
  def __eq__(self, other):
19438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19439 
 
19440 
  def __ne__(self, other):
19441 
    return not (self == other)
19442 
 
19443 
class addOrUpdateFreebieForItem_result:
19444 
 
19445 
  thrift_spec = (
19446 
  )
19447 
 
19448 
  def read(self, iprot):
19449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19451 
      return
19452 
    iprot.readStructBegin()
19453 
    while True:
19454 
      (fname, ftype, fid) = iprot.readFieldBegin()
19455 
      if ftype == TType.STOP:
19456 
        break
19457 
      else:
19458 
        iprot.skip(ftype)
19459 
      iprot.readFieldEnd()
19460 
    iprot.readStructEnd()
19461 
 
19462 
  def write(self, oprot):
19463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19465 
      return
19466 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19467 
    oprot.writeFieldStop()
19468 
    oprot.writeStructEnd()
19469 
 
19470 
  def validate(self):
19471 
    return
19472 
 
19473 
 
19474 
  def __repr__(self):
19475 
    L = ['%s=%r' % (key, value)
19476 
      for key, value in self.__dict__.iteritems()]
19477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19478 
 
19479 
  def __eq__(self, other):
19480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19481 
 
19482 
  def __ne__(self, other):
19483 
    return not (self == other)
7256 rajveer 19484 
 
7272 amit.gupta 19485 
class addOrUpdateBrandInfo_args:
19486 
  """
19487 
  Attributes:
19488 
   - brandInfo
19489 
  """
19490 
 
19491 
  thrift_spec = (
19492 
    None, # 0
19493 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19494 
  )
19495 
 
19496 
  def __init__(self, brandInfo=None,):
19497 
    self.brandInfo = brandInfo
19498 
 
19499 
  def read(self, iprot):
19500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19502 
      return
19503 
    iprot.readStructBegin()
19504 
    while True:
19505 
      (fname, ftype, fid) = iprot.readFieldBegin()
19506 
      if ftype == TType.STOP:
19507 
        break
19508 
      if fid == 1:
19509 
        if ftype == TType.STRUCT:
19510 
          self.brandInfo = BrandInfo()
19511 
          self.brandInfo.read(iprot)
19512 
        else:
19513 
          iprot.skip(ftype)
19514 
      else:
19515 
        iprot.skip(ftype)
19516 
      iprot.readFieldEnd()
19517 
    iprot.readStructEnd()
19518 
 
19519 
  def write(self, oprot):
19520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19522 
      return
19523 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19524 
    if self.brandInfo is not None:
19525 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19526 
      self.brandInfo.write(oprot)
19527 
      oprot.writeFieldEnd()
19528 
    oprot.writeFieldStop()
19529 
    oprot.writeStructEnd()
19530 
 
19531 
  def validate(self):
19532 
    return
19533 
 
19534 
 
19535 
  def __repr__(self):
19536 
    L = ['%s=%r' % (key, value)
19537 
      for key, value in self.__dict__.iteritems()]
19538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19539 
 
19540 
  def __eq__(self, other):
19541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19542 
 
19543 
  def __ne__(self, other):
19544 
    return not (self == other)
19545 
 
19546 
class addOrUpdateBrandInfo_result:
19547 
 
19548 
  thrift_spec = (
19549 
  )
19550 
 
19551 
  def read(self, iprot):
19552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19554 
      return
19555 
    iprot.readStructBegin()
19556 
    while True:
19557 
      (fname, ftype, fid) = iprot.readFieldBegin()
19558 
      if ftype == TType.STOP:
19559 
        break
19560 
      else:
19561 
        iprot.skip(ftype)
19562 
      iprot.readFieldEnd()
19563 
    iprot.readStructEnd()
19564 
 
19565 
  def write(self, oprot):
19566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19568 
      return
19569 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19570 
    oprot.writeFieldStop()
19571 
    oprot.writeStructEnd()
19572 
 
19573 
  def validate(self):
19574 
    return
19575 
 
19576 
 
19577 
  def __repr__(self):
19578 
    L = ['%s=%r' % (key, value)
19579 
      for key, value in self.__dict__.iteritems()]
19580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19581 
 
19582 
  def __eq__(self, other):
19583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19584 
 
19585 
  def __ne__(self, other):
19586 
    return not (self == other)
19587 
 
19588 
class getBrandInfo_args:
19589 
 
19590 
  thrift_spec = (
19591 
  )
19592 
 
19593 
  def read(self, iprot):
19594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19596 
      return
19597 
    iprot.readStructBegin()
19598 
    while True:
19599 
      (fname, ftype, fid) = iprot.readFieldBegin()
19600 
      if ftype == TType.STOP:
19601 
        break
19602 
      else:
19603 
        iprot.skip(ftype)
19604 
      iprot.readFieldEnd()
19605 
    iprot.readStructEnd()
19606 
 
19607 
  def write(self, oprot):
19608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19610 
      return
19611 
    oprot.writeStructBegin('getBrandInfo_args')
19612 
    oprot.writeFieldStop()
19613 
    oprot.writeStructEnd()
19614 
 
19615 
  def validate(self):
19616 
    return
19617 
 
19618 
 
19619 
  def __repr__(self):
19620 
    L = ['%s=%r' % (key, value)
19621 
      for key, value in self.__dict__.iteritems()]
19622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19623 
 
19624 
  def __eq__(self, other):
19625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19626 
 
19627 
  def __ne__(self, other):
19628 
    return not (self == other)
19629 
 
19630 
class getBrandInfo_result:
19631 
  """
19632 
  Attributes:
19633 
   - success
19634 
  """
19635 
 
19636 
  thrift_spec = (
19637 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19638 
  )
19639 
 
19640 
  def __init__(self, success=None,):
19641 
    self.success = success
19642 
 
19643 
  def read(self, iprot):
19644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19646 
      return
19647 
    iprot.readStructBegin()
19648 
    while True:
19649 
      (fname, ftype, fid) = iprot.readFieldBegin()
19650 
      if ftype == TType.STOP:
19651 
        break
19652 
      if fid == 0:
19653 
        if ftype == TType.MAP:
19654 
          self.success = {}
9155 kshitij.so 19655 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19656 
          for _i392 in xrange(_size388):
19657 
            _key393 = iprot.readString();
19658 
            _val394 = BrandInfo()
19659 
            _val394.read(iprot)
19660 
            self.success[_key393] = _val394
7272 amit.gupta 19661 
          iprot.readMapEnd()
19662 
        else:
19663 
          iprot.skip(ftype)
19664 
      else:
19665 
        iprot.skip(ftype)
19666 
      iprot.readFieldEnd()
19667 
    iprot.readStructEnd()
19668 
 
19669 
  def write(self, oprot):
19670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19672 
      return
19673 
    oprot.writeStructBegin('getBrandInfo_result')
19674 
    if self.success is not None:
19675 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19676 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19677 
      for kiter395,viter396 in self.success.items():
19678 
        oprot.writeString(kiter395)
19679 
        viter396.write(oprot)
7272 amit.gupta 19680 
      oprot.writeMapEnd()
19681 
      oprot.writeFieldEnd()
19682 
    oprot.writeFieldStop()
19683 
    oprot.writeStructEnd()
19684 
 
19685 
  def validate(self):
19686 
    return
19687 
 
19688 
 
19689 
  def __repr__(self):
19690 
    L = ['%s=%r' % (key, value)
19691 
      for key, value in self.__dict__.iteritems()]
19692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19693 
 
19694 
  def __eq__(self, other):
19695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19696 
 
19697 
  def __ne__(self, other):
19698 
    return not (self == other)
19699 
 
7256 rajveer 19700 
class getStorePricing_args:
19701 
  """
19702 
  Attributes:
19703 
   - itemId
19704 
  """
19705 
 
19706 
  thrift_spec = (
19707 
    None, # 0
19708 
    (1, TType.I64, 'itemId', None, None, ), # 1
19709 
  )
19710 
 
19711 
  def __init__(self, itemId=None,):
19712 
    self.itemId = itemId
19713 
 
19714 
  def read(self, iprot):
19715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19717 
      return
19718 
    iprot.readStructBegin()
19719 
    while True:
19720 
      (fname, ftype, fid) = iprot.readFieldBegin()
19721 
      if ftype == TType.STOP:
19722 
        break
19723 
      if fid == 1:
19724 
        if ftype == TType.I64:
19725 
          self.itemId = iprot.readI64();
19726 
        else:
19727 
          iprot.skip(ftype)
19728 
      else:
19729 
        iprot.skip(ftype)
19730 
      iprot.readFieldEnd()
19731 
    iprot.readStructEnd()
19732 
 
19733 
  def write(self, oprot):
19734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19736 
      return
19737 
    oprot.writeStructBegin('getStorePricing_args')
19738 
    if self.itemId is not None:
19739 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19740 
      oprot.writeI64(self.itemId)
19741 
      oprot.writeFieldEnd()
19742 
    oprot.writeFieldStop()
19743 
    oprot.writeStructEnd()
19744 
 
19745 
  def validate(self):
19746 
    return
19747 
 
19748 
 
19749 
  def __repr__(self):
19750 
    L = ['%s=%r' % (key, value)
19751 
      for key, value in self.__dict__.iteritems()]
19752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19753 
 
19754 
  def __eq__(self, other):
19755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19756 
 
19757 
  def __ne__(self, other):
19758 
    return not (self == other)
19759 
 
19760 
class getStorePricing_result:
19761 
  """
19762 
  Attributes:
19763 
   - success
19764 
  """
19765 
 
19766 
  thrift_spec = (
19767 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19768 
  )
19769 
 
19770 
  def __init__(self, success=None,):
19771 
    self.success = success
19772 
 
19773 
  def read(self, iprot):
19774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19776 
      return
19777 
    iprot.readStructBegin()
19778 
    while True:
19779 
      (fname, ftype, fid) = iprot.readFieldBegin()
19780 
      if ftype == TType.STOP:
19781 
        break
19782 
      if fid == 0:
19783 
        if ftype == TType.STRUCT:
19784 
          self.success = StorePricing()
19785 
          self.success.read(iprot)
19786 
        else:
19787 
          iprot.skip(ftype)
19788 
      else:
19789 
        iprot.skip(ftype)
19790 
      iprot.readFieldEnd()
19791 
    iprot.readStructEnd()
19792 
 
19793 
  def write(self, oprot):
19794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19796 
      return
19797 
    oprot.writeStructBegin('getStorePricing_result')
19798 
    if self.success is not None:
19799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19800 
      self.success.write(oprot)
19801 
      oprot.writeFieldEnd()
19802 
    oprot.writeFieldStop()
19803 
    oprot.writeStructEnd()
19804 
 
19805 
  def validate(self):
19806 
    return
19807 
 
19808 
 
19809 
  def __repr__(self):
19810 
    L = ['%s=%r' % (key, value)
19811 
      for key, value in self.__dict__.iteritems()]
19812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19813 
 
19814 
  def __eq__(self, other):
19815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19816 
 
19817 
  def __ne__(self, other):
19818 
    return not (self == other)
7265 rajveer 19819 
 
7306 rajveer 19820 
class getStorePricings_args:
19821 
  """
19822 
  Attributes:
19823 
   - itemIds
19824 
  """
19825 
 
19826 
  thrift_spec = (
19827 
    None, # 0
19828 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19829 
  )
19830 
 
19831 
  def __init__(self, itemIds=None,):
19832 
    self.itemIds = itemIds
19833 
 
19834 
  def read(self, iprot):
19835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19837 
      return
19838 
    iprot.readStructBegin()
19839 
    while True:
19840 
      (fname, ftype, fid) = iprot.readFieldBegin()
19841 
      if ftype == TType.STOP:
19842 
        break
19843 
      if fid == 1:
19844 
        if ftype == TType.LIST:
19845 
          self.itemIds = []
9155 kshitij.so 19846 
          (_etype400, _size397) = iprot.readListBegin()
19847 
          for _i401 in xrange(_size397):
19848 
            _elem402 = iprot.readI64();
19849 
            self.itemIds.append(_elem402)
7306 rajveer 19850 
          iprot.readListEnd()
19851 
        else:
19852 
          iprot.skip(ftype)
19853 
      else:
19854 
        iprot.skip(ftype)
19855 
      iprot.readFieldEnd()
19856 
    iprot.readStructEnd()
19857 
 
19858 
  def write(self, oprot):
19859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19861 
      return
19862 
    oprot.writeStructBegin('getStorePricings_args')
19863 
    if self.itemIds is not None:
19864 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19865 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19866 
      for iter403 in self.itemIds:
19867 
        oprot.writeI64(iter403)
7306 rajveer 19868 
      oprot.writeListEnd()
19869 
      oprot.writeFieldEnd()
19870 
    oprot.writeFieldStop()
19871 
    oprot.writeStructEnd()
19872 
 
19873 
  def validate(self):
19874 
    return
19875 
 
19876 
 
19877 
  def __repr__(self):
19878 
    L = ['%s=%r' % (key, value)
19879 
      for key, value in self.__dict__.iteritems()]
19880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19881 
 
19882 
  def __eq__(self, other):
19883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19884 
 
19885 
  def __ne__(self, other):
19886 
    return not (self == other)
19887 
 
19888 
class getStorePricings_result:
19889 
  """
19890 
  Attributes:
19891 
   - success
19892 
  """
19893 
 
19894 
  thrift_spec = (
19895 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19896 
  )
19897 
 
19898 
  def __init__(self, success=None,):
19899 
    self.success = success
19900 
 
19901 
  def read(self, iprot):
19902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19904 
      return
19905 
    iprot.readStructBegin()
19906 
    while True:
19907 
      (fname, ftype, fid) = iprot.readFieldBegin()
19908 
      if ftype == TType.STOP:
19909 
        break
19910 
      if fid == 0:
19911 
        if ftype == TType.LIST:
19912 
          self.success = []
9155 kshitij.so 19913 
          (_etype407, _size404) = iprot.readListBegin()
19914 
          for _i408 in xrange(_size404):
19915 
            _elem409 = StorePricing()
19916 
            _elem409.read(iprot)
19917 
            self.success.append(_elem409)
7306 rajveer 19918 
          iprot.readListEnd()
19919 
        else:
19920 
          iprot.skip(ftype)
19921 
      else:
19922 
        iprot.skip(ftype)
19923 
      iprot.readFieldEnd()
19924 
    iprot.readStructEnd()
19925 
 
19926 
  def write(self, oprot):
19927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19929 
      return
19930 
    oprot.writeStructBegin('getStorePricings_result')
19931 
    if self.success is not None:
19932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19933 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19934 
      for iter410 in self.success:
19935 
        iter410.write(oprot)
7306 rajveer 19936 
      oprot.writeListEnd()
19937 
      oprot.writeFieldEnd()
19938 
    oprot.writeFieldStop()
19939 
    oprot.writeStructEnd()
19940 
 
19941 
  def validate(self):
19942 
    return
19943 
 
19944 
 
19945 
  def __repr__(self):
19946 
    L = ['%s=%r' % (key, value)
19947 
      for key, value in self.__dict__.iteritems()]
19948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19949 
 
19950 
  def __eq__(self, other):
19951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19952 
 
19953 
  def __ne__(self, other):
19954 
    return not (self == other)
19955 
 
7265 rajveer 19956 
class updateStorePricing_args:
19957 
  """
19958 
  Attributes:
19959 
   - sp
7382 rajveer 19960 
   - allColors
7265 rajveer 19961 
  """
19962 
 
19963 
  thrift_spec = (
19964 
    None, # 0
19965 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19966 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19967 
  )
19968 
 
7382 rajveer 19969 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19970 
    self.sp = sp
7382 rajveer 19971 
    self.allColors = allColors
7265 rajveer 19972 
 
19973 
  def read(self, iprot):
19974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19976 
      return
19977 
    iprot.readStructBegin()
19978 
    while True:
19979 
      (fname, ftype, fid) = iprot.readFieldBegin()
19980 
      if ftype == TType.STOP:
19981 
        break
19982 
      if fid == 1:
19983 
        if ftype == TType.STRUCT:
19984 
          self.sp = StorePricing()
19985 
          self.sp.read(iprot)
19986 
        else:
19987 
          iprot.skip(ftype)
7382 rajveer 19988 
      elif fid == 2:
19989 
        if ftype == TType.BOOL:
19990 
          self.allColors = iprot.readBool();
19991 
        else:
19992 
          iprot.skip(ftype)
7265 rajveer 19993 
      else:
19994 
        iprot.skip(ftype)
19995 
      iprot.readFieldEnd()
19996 
    iprot.readStructEnd()
19997 
 
19998 
  def write(self, oprot):
19999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20001 
      return
20002 
    oprot.writeStructBegin('updateStorePricing_args')
20003 
    if self.sp is not None:
20004 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20005 
      self.sp.write(oprot)
20006 
      oprot.writeFieldEnd()
7382 rajveer 20007 
    if self.allColors is not None:
20008 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20009 
      oprot.writeBool(self.allColors)
20010 
      oprot.writeFieldEnd()
7265 rajveer 20011 
    oprot.writeFieldStop()
20012 
    oprot.writeStructEnd()
20013 
 
20014 
  def validate(self):
20015 
    return
20016 
 
20017 
 
20018 
  def __repr__(self):
20019 
    L = ['%s=%r' % (key, value)
20020 
      for key, value in self.__dict__.iteritems()]
20021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20022 
 
20023 
  def __eq__(self, other):
20024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20025 
 
20026 
  def __ne__(self, other):
20027 
    return not (self == other)
20028 
 
20029 
class updateStorePricing_result:
20030 
 
20031 
  thrift_spec = (
20032 
  )
20033 
 
20034 
  def read(self, iprot):
20035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20037 
      return
20038 
    iprot.readStructBegin()
20039 
    while True:
20040 
      (fname, ftype, fid) = iprot.readFieldBegin()
20041 
      if ftype == TType.STOP:
20042 
        break
20043 
      else:
20044 
        iprot.skip(ftype)
20045 
      iprot.readFieldEnd()
20046 
    iprot.readStructEnd()
20047 
 
20048 
  def write(self, oprot):
20049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20051 
      return
20052 
    oprot.writeStructBegin('updateStorePricing_result')
20053 
    oprot.writeFieldStop()
20054 
    oprot.writeStructEnd()
20055 
 
20056 
  def validate(self):
20057 
    return
20058 
 
20059 
 
20060 
  def __repr__(self):
20061 
    L = ['%s=%r' % (key, value)
20062 
      for key, value in self.__dict__.iteritems()]
20063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20064 
 
20065 
  def __eq__(self, other):
20066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20067 
 
20068 
  def __ne__(self, other):
20069 
    return not (self == other)
7281 kshitij.so 20070 
 
20071 
class getAllAmazonListedItems_args:
20072 
 
20073 
  thrift_spec = (
20074 
  )
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      else:
20086 
        iprot.skip(ftype)
20087 
      iprot.readFieldEnd()
20088 
    iprot.readStructEnd()
20089 
 
20090 
  def write(self, oprot):
20091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20093 
      return
20094 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20095 
    oprot.writeFieldStop()
20096 
    oprot.writeStructEnd()
20097 
 
20098 
  def validate(self):
20099 
    return
20100 
 
20101 
 
20102 
  def __repr__(self):
20103 
    L = ['%s=%r' % (key, value)
20104 
      for key, value in self.__dict__.iteritems()]
20105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20106 
 
20107 
  def __eq__(self, other):
20108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20109 
 
20110 
  def __ne__(self, other):
20111 
    return not (self == other)
20112 
 
20113 
class getAllAmazonListedItems_result:
20114 
  """
20115 
  Attributes:
20116 
   - success
20117 
  """
20118 
 
20119 
  thrift_spec = (
20120 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20121 
  )
20122 
 
20123 
  def __init__(self, success=None,):
20124 
    self.success = success
20125 
 
20126 
  def read(self, iprot):
20127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20129 
      return
20130 
    iprot.readStructBegin()
20131 
    while True:
20132 
      (fname, ftype, fid) = iprot.readFieldBegin()
20133 
      if ftype == TType.STOP:
20134 
        break
20135 
      if fid == 0:
20136 
        if ftype == TType.LIST:
20137 
          self.success = []
9155 kshitij.so 20138 
          (_etype414, _size411) = iprot.readListBegin()
20139 
          for _i415 in xrange(_size411):
20140 
            _elem416 = Amazonlisted()
20141 
            _elem416.read(iprot)
20142 
            self.success.append(_elem416)
7281 kshitij.so 20143 
          iprot.readListEnd()
20144 
        else:
20145 
          iprot.skip(ftype)
20146 
      else:
20147 
        iprot.skip(ftype)
20148 
      iprot.readFieldEnd()
20149 
    iprot.readStructEnd()
20150 
 
20151 
  def write(self, oprot):
20152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20154 
      return
20155 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20156 
    if self.success is not None:
20157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20159 
      for iter417 in self.success:
20160 
        iter417.write(oprot)
7281 kshitij.so 20161 
      oprot.writeListEnd()
20162 
      oprot.writeFieldEnd()
20163 
    oprot.writeFieldStop()
20164 
    oprot.writeStructEnd()
20165 
 
20166 
  def validate(self):
20167 
    return
20168 
 
20169 
 
20170 
  def __repr__(self):
20171 
    L = ['%s=%r' % (key, value)
20172 
      for key, value in self.__dict__.iteritems()]
20173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20174 
 
20175 
  def __eq__(self, other):
20176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20177 
 
20178 
  def __ne__(self, other):
20179 
    return not (self == other)
20180 
 
8619 kshitij.so 20181 
class searchAmazonItems_args:
20182 
  """
20183 
  Attributes:
20184 
   - searchTerm
20185 
   - offset
20186 
   - limit
20187 
  """
20188 
 
20189 
  thrift_spec = (
20190 
    None, # 0
20191 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20192 
    (2, TType.I64, 'offset', None, None, ), # 2
20193 
    (3, TType.I64, 'limit', None, None, ), # 3
20194 
  )
20195 
 
20196 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20197 
    self.searchTerm = searchTerm
20198 
    self.offset = offset
20199 
    self.limit = limit
20200 
 
20201 
  def read(self, iprot):
20202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20204 
      return
20205 
    iprot.readStructBegin()
20206 
    while True:
20207 
      (fname, ftype, fid) = iprot.readFieldBegin()
20208 
      if ftype == TType.STOP:
20209 
        break
20210 
      if fid == 1:
20211 
        if ftype == TType.LIST:
20212 
          self.searchTerm = []
9155 kshitij.so 20213 
          (_etype421, _size418) = iprot.readListBegin()
20214 
          for _i422 in xrange(_size418):
20215 
            _elem423 = iprot.readString();
20216 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20217 
          iprot.readListEnd()
20218 
        else:
20219 
          iprot.skip(ftype)
20220 
      elif fid == 2:
20221 
        if ftype == TType.I64:
20222 
          self.offset = iprot.readI64();
20223 
        else:
20224 
          iprot.skip(ftype)
20225 
      elif fid == 3:
20226 
        if ftype == TType.I64:
20227 
          self.limit = iprot.readI64();
20228 
        else:
20229 
          iprot.skip(ftype)
20230 
      else:
20231 
        iprot.skip(ftype)
20232 
      iprot.readFieldEnd()
20233 
    iprot.readStructEnd()
20234 
 
20235 
  def write(self, oprot):
20236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20238 
      return
20239 
    oprot.writeStructBegin('searchAmazonItems_args')
20240 
    if self.searchTerm is not None:
20241 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20242 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20243 
      for iter424 in self.searchTerm:
20244 
        oprot.writeString(iter424)
8619 kshitij.so 20245 
      oprot.writeListEnd()
20246 
      oprot.writeFieldEnd()
20247 
    if self.offset is not None:
20248 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20249 
      oprot.writeI64(self.offset)
20250 
      oprot.writeFieldEnd()
20251 
    if self.limit is not None:
20252 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20253 
      oprot.writeI64(self.limit)
20254 
      oprot.writeFieldEnd()
20255 
    oprot.writeFieldStop()
20256 
    oprot.writeStructEnd()
20257 
 
20258 
  def validate(self):
20259 
    return
20260 
 
20261 
 
20262 
  def __repr__(self):
20263 
    L = ['%s=%r' % (key, value)
20264 
      for key, value in self.__dict__.iteritems()]
20265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20266 
 
20267 
  def __eq__(self, other):
20268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20269 
 
20270 
  def __ne__(self, other):
20271 
    return not (self == other)
20272 
 
20273 
class searchAmazonItems_result:
20274 
  """
20275 
  Attributes:
20276 
   - success
20277 
  """
20278 
 
20279 
  thrift_spec = (
20280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20281 
  )
20282 
 
20283 
  def __init__(self, success=None,):
20284 
    self.success = success
20285 
 
20286 
  def read(self, iprot):
20287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20289 
      return
20290 
    iprot.readStructBegin()
20291 
    while True:
20292 
      (fname, ftype, fid) = iprot.readFieldBegin()
20293 
      if ftype == TType.STOP:
20294 
        break
20295 
      if fid == 0:
20296 
        if ftype == TType.LIST:
20297 
          self.success = []
9155 kshitij.so 20298 
          (_etype428, _size425) = iprot.readListBegin()
20299 
          for _i429 in xrange(_size425):
20300 
            _elem430 = Amazonlisted()
20301 
            _elem430.read(iprot)
20302 
            self.success.append(_elem430)
8619 kshitij.so 20303 
          iprot.readListEnd()
20304 
        else:
20305 
          iprot.skip(ftype)
20306 
      else:
20307 
        iprot.skip(ftype)
20308 
      iprot.readFieldEnd()
20309 
    iprot.readStructEnd()
20310 
 
20311 
  def write(self, oprot):
20312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20314 
      return
20315 
    oprot.writeStructBegin('searchAmazonItems_result')
20316 
    if self.success is not None:
20317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20319 
      for iter431 in self.success:
20320 
        iter431.write(oprot)
8619 kshitij.so 20321 
      oprot.writeListEnd()
20322 
      oprot.writeFieldEnd()
20323 
    oprot.writeFieldStop()
20324 
    oprot.writeStructEnd()
20325 
 
20326 
  def validate(self):
20327 
    return
20328 
 
20329 
 
20330 
  def __repr__(self):
20331 
    L = ['%s=%r' % (key, value)
20332 
      for key, value in self.__dict__.iteritems()]
20333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20334 
 
20335 
  def __eq__(self, other):
20336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20337 
 
20338 
  def __ne__(self, other):
20339 
    return not (self == other)
20340 
 
20341 
class getAmazonSearchResultCount_args:
20342 
  """
20343 
  Attributes:
20344 
   - searchTerm
20345 
  """
20346 
 
20347 
  thrift_spec = (
20348 
    None, # 0
20349 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20350 
  )
20351 
 
20352 
  def __init__(self, searchTerm=None,):
20353 
    self.searchTerm = searchTerm
20354 
 
20355 
  def read(self, iprot):
20356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20358 
      return
20359 
    iprot.readStructBegin()
20360 
    while True:
20361 
      (fname, ftype, fid) = iprot.readFieldBegin()
20362 
      if ftype == TType.STOP:
20363 
        break
20364 
      if fid == 1:
20365 
        if ftype == TType.LIST:
20366 
          self.searchTerm = []
9155 kshitij.so 20367 
          (_etype435, _size432) = iprot.readListBegin()
20368 
          for _i436 in xrange(_size432):
20369 
            _elem437 = iprot.readString();
20370 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20371 
          iprot.readListEnd()
20372 
        else:
20373 
          iprot.skip(ftype)
20374 
      else:
20375 
        iprot.skip(ftype)
20376 
      iprot.readFieldEnd()
20377 
    iprot.readStructEnd()
20378 
 
20379 
  def write(self, oprot):
20380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20382 
      return
20383 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20384 
    if self.searchTerm is not None:
20385 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20386 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20387 
      for iter438 in self.searchTerm:
20388 
        oprot.writeString(iter438)
8619 kshitij.so 20389 
      oprot.writeListEnd()
20390 
      oprot.writeFieldEnd()
20391 
    oprot.writeFieldStop()
20392 
    oprot.writeStructEnd()
20393 
 
20394 
  def validate(self):
20395 
    return
20396 
 
20397 
 
20398 
  def __repr__(self):
20399 
    L = ['%s=%r' % (key, value)
20400 
      for key, value in self.__dict__.iteritems()]
20401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20402 
 
20403 
  def __eq__(self, other):
20404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20405 
 
20406 
  def __ne__(self, other):
20407 
    return not (self == other)
20408 
 
20409 
class getAmazonSearchResultCount_result:
20410 
  """
20411 
  Attributes:
20412 
   - success
20413 
  """
20414 
 
20415 
  thrift_spec = (
20416 
    (0, TType.I64, 'success', None, None, ), # 0
20417 
  )
20418 
 
20419 
  def __init__(self, success=None,):
20420 
    self.success = success
20421 
 
20422 
  def read(self, iprot):
20423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20425 
      return
20426 
    iprot.readStructBegin()
20427 
    while True:
20428 
      (fname, ftype, fid) = iprot.readFieldBegin()
20429 
      if ftype == TType.STOP:
20430 
        break
20431 
      if fid == 0:
20432 
        if ftype == TType.I64:
20433 
          self.success = iprot.readI64();
20434 
        else:
20435 
          iprot.skip(ftype)
20436 
      else:
20437 
        iprot.skip(ftype)
20438 
      iprot.readFieldEnd()
20439 
    iprot.readStructEnd()
20440 
 
20441 
  def write(self, oprot):
20442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20444 
      return
20445 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20446 
    if self.success is not None:
20447 
      oprot.writeFieldBegin('success', TType.I64, 0)
20448 
      oprot.writeI64(self.success)
20449 
      oprot.writeFieldEnd()
20450 
    oprot.writeFieldStop()
20451 
    oprot.writeStructEnd()
20452 
 
20453 
  def validate(self):
20454 
    return
20455 
 
20456 
 
20457 
  def __repr__(self):
20458 
    L = ['%s=%r' % (key, value)
20459 
      for key, value in self.__dict__.iteritems()]
20460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20461 
 
20462 
  def __eq__(self, other):
20463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20464 
 
20465 
  def __ne__(self, other):
20466 
    return not (self == other)
20467 
 
20468 
class getCountForAmazonlistedItems_args:
20469 
 
20470 
  thrift_spec = (
20471 
  )
20472 
 
20473 
  def read(self, iprot):
20474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20476 
      return
20477 
    iprot.readStructBegin()
20478 
    while True:
20479 
      (fname, ftype, fid) = iprot.readFieldBegin()
20480 
      if ftype == TType.STOP:
20481 
        break
20482 
      else:
20483 
        iprot.skip(ftype)
20484 
      iprot.readFieldEnd()
20485 
    iprot.readStructEnd()
20486 
 
20487 
  def write(self, oprot):
20488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20490 
      return
20491 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20492 
    oprot.writeFieldStop()
20493 
    oprot.writeStructEnd()
20494 
 
20495 
  def validate(self):
20496 
    return
20497 
 
20498 
 
20499 
  def __repr__(self):
20500 
    L = ['%s=%r' % (key, value)
20501 
      for key, value in self.__dict__.iteritems()]
20502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20503 
 
20504 
  def __eq__(self, other):
20505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20506 
 
20507 
  def __ne__(self, other):
20508 
    return not (self == other)
20509 
 
20510 
class getCountForAmazonlistedItems_result:
20511 
  """
20512 
  Attributes:
20513 
   - success
20514 
  """
20515 
 
20516 
  thrift_spec = (
20517 
    (0, TType.I64, 'success', None, None, ), # 0
20518 
  )
20519 
 
20520 
  def __init__(self, success=None,):
20521 
    self.success = success
20522 
 
20523 
  def read(self, iprot):
20524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20526 
      return
20527 
    iprot.readStructBegin()
20528 
    while True:
20529 
      (fname, ftype, fid) = iprot.readFieldBegin()
20530 
      if ftype == TType.STOP:
20531 
        break
20532 
      if fid == 0:
20533 
        if ftype == TType.I64:
20534 
          self.success = iprot.readI64();
20535 
        else:
20536 
          iprot.skip(ftype)
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_result')
20547 
    if self.success is not None:
20548 
      oprot.writeFieldBegin('success', TType.I64, 0)
20549 
      oprot.writeI64(self.success)
20550 
      oprot.writeFieldEnd()
20551 
    oprot.writeFieldStop()
20552 
    oprot.writeStructEnd()
20553 
 
20554 
  def validate(self):
20555 
    return
20556 
 
20557 
 
20558 
  def __repr__(self):
20559 
    L = ['%s=%r' % (key, value)
20560 
      for key, value in self.__dict__.iteritems()]
20561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20562 
 
20563 
  def __eq__(self, other):
20564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20565 
 
20566 
  def __ne__(self, other):
20567 
    return not (self == other)
20568 
 
7281 kshitij.so 20569 
class getAmazonItemDetails_args:
20570 
  """
20571 
  Attributes:
20572 
   - itemId
20573 
  """
20574 
 
20575 
  thrift_spec = (
20576 
    None, # 0
20577 
    (1, TType.I64, 'itemId', None, None, ), # 1
20578 
  )
20579 
 
20580 
  def __init__(self, itemId=None,):
20581 
    self.itemId = itemId
20582 
 
20583 
  def read(self, iprot):
20584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20586 
      return
20587 
    iprot.readStructBegin()
20588 
    while True:
20589 
      (fname, ftype, fid) = iprot.readFieldBegin()
20590 
      if ftype == TType.STOP:
20591 
        break
20592 
      if fid == 1:
20593 
        if ftype == TType.I64:
20594 
          self.itemId = iprot.readI64();
20595 
        else:
20596 
          iprot.skip(ftype)
20597 
      else:
20598 
        iprot.skip(ftype)
20599 
      iprot.readFieldEnd()
20600 
    iprot.readStructEnd()
20601 
 
20602 
  def write(self, oprot):
20603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20605 
      return
20606 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20607 
    if self.itemId is not None:
20608 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20609 
      oprot.writeI64(self.itemId)
20610 
      oprot.writeFieldEnd()
20611 
    oprot.writeFieldStop()
20612 
    oprot.writeStructEnd()
20613 
 
20614 
  def validate(self):
20615 
    return
20616 
 
20617 
 
20618 
  def __repr__(self):
20619 
    L = ['%s=%r' % (key, value)
20620 
      for key, value in self.__dict__.iteritems()]
20621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20622 
 
20623 
  def __eq__(self, other):
20624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20625 
 
20626 
  def __ne__(self, other):
20627 
    return not (self == other)
20628 
 
20629 
class getAmazonItemDetails_result:
20630 
  """
20631 
  Attributes:
20632 
   - success
20633 
  """
20634 
 
20635 
  thrift_spec = (
20636 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20637 
  )
20638 
 
20639 
  def __init__(self, success=None,):
20640 
    self.success = success
20641 
 
20642 
  def read(self, iprot):
20643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20645 
      return
20646 
    iprot.readStructBegin()
20647 
    while True:
20648 
      (fname, ftype, fid) = iprot.readFieldBegin()
20649 
      if ftype == TType.STOP:
20650 
        break
20651 
      if fid == 0:
20652 
        if ftype == TType.STRUCT:
20653 
          self.success = Amazonlisted()
20654 
          self.success.read(iprot)
20655 
        else:
20656 
          iprot.skip(ftype)
20657 
      else:
20658 
        iprot.skip(ftype)
20659 
      iprot.readFieldEnd()
20660 
    iprot.readStructEnd()
20661 
 
20662 
  def write(self, oprot):
20663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20665 
      return
20666 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20667 
    if self.success is not None:
20668 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20669 
      self.success.write(oprot)
20670 
      oprot.writeFieldEnd()
20671 
    oprot.writeFieldStop()
20672 
    oprot.writeStructEnd()
20673 
 
20674 
  def validate(self):
20675 
    return
20676 
 
20677 
 
20678 
  def __repr__(self):
20679 
    L = ['%s=%r' % (key, value)
20680 
      for key, value in self.__dict__.iteritems()]
20681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20682 
 
20683 
  def __eq__(self, other):
20684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20685 
 
20686 
  def __ne__(self, other):
20687 
    return not (self == other)
20688 
 
20689 
class updateAmazonItemDetails_args:
20690 
  """
20691 
  Attributes:
8168 kshitij.so 20692 
   - amazonlisted
7281 kshitij.so 20693 
  """
20694 
 
20695 
  thrift_spec = (
20696 
    None, # 0
8168 kshitij.so 20697 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20698 
  )
20699 
 
8168 kshitij.so 20700 
  def __init__(self, amazonlisted=None,):
20701 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20702 
 
20703 
  def read(self, iprot):
20704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20706 
      return
20707 
    iprot.readStructBegin()
20708 
    while True:
20709 
      (fname, ftype, fid) = iprot.readFieldBegin()
20710 
      if ftype == TType.STOP:
20711 
        break
20712 
      if fid == 1:
8168 kshitij.so 20713 
        if ftype == TType.STRUCT:
20714 
          self.amazonlisted = Amazonlisted()
20715 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20716 
        else:
20717 
          iprot.skip(ftype)
20718 
      else:
20719 
        iprot.skip(ftype)
20720 
      iprot.readFieldEnd()
20721 
    iprot.readStructEnd()
20722 
 
20723 
  def write(self, oprot):
20724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20726 
      return
20727 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20728 
    if self.amazonlisted is not None:
20729 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20730 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20731 
      oprot.writeFieldEnd()
20732 
    oprot.writeFieldStop()
20733 
    oprot.writeStructEnd()
20734 
 
20735 
  def validate(self):
20736 
    return
20737 
 
20738 
 
20739 
  def __repr__(self):
20740 
    L = ['%s=%r' % (key, value)
20741 
      for key, value in self.__dict__.iteritems()]
20742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20743 
 
20744 
  def __eq__(self, other):
20745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20746 
 
20747 
  def __ne__(self, other):
20748 
    return not (self == other)
20749 
 
20750 
class updateAmazonItemDetails_result:
20751 
 
20752 
  thrift_spec = (
20753 
  )
20754 
 
20755 
  def read(self, iprot):
20756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20758 
      return
20759 
    iprot.readStructBegin()
20760 
    while True:
20761 
      (fname, ftype, fid) = iprot.readFieldBegin()
20762 
      if ftype == TType.STOP:
20763 
        break
20764 
      else:
20765 
        iprot.skip(ftype)
20766 
      iprot.readFieldEnd()
20767 
    iprot.readStructEnd()
20768 
 
20769 
  def write(self, oprot):
20770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20772 
      return
20773 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20774 
    oprot.writeFieldStop()
20775 
    oprot.writeStructEnd()
20776 
 
20777 
  def validate(self):
20778 
    return
20779 
 
20780 
 
20781 
  def __repr__(self):
20782 
    L = ['%s=%r' % (key, value)
20783 
      for key, value in self.__dict__.iteritems()]
20784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20785 
 
20786 
  def __eq__(self, other):
20787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20788 
 
20789 
  def __ne__(self, other):
20790 
    return not (self == other)
20791 
 
20792 
class addAmazonItem_args:
20793 
  """
20794 
  Attributes:
20795 
   - amazonlisted
20796 
  """
20797 
 
20798 
  thrift_spec = (
20799 
    None, # 0
20800 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20801 
  )
20802 
 
20803 
  def __init__(self, amazonlisted=None,):
20804 
    self.amazonlisted = amazonlisted
20805 
 
20806 
  def read(self, iprot):
20807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20809 
      return
20810 
    iprot.readStructBegin()
20811 
    while True:
20812 
      (fname, ftype, fid) = iprot.readFieldBegin()
20813 
      if ftype == TType.STOP:
20814 
        break
20815 
      if fid == 1:
20816 
        if ftype == TType.STRUCT:
20817 
          self.amazonlisted = Amazonlisted()
20818 
          self.amazonlisted.read(iprot)
20819 
        else:
20820 
          iprot.skip(ftype)
20821 
      else:
20822 
        iprot.skip(ftype)
20823 
      iprot.readFieldEnd()
20824 
    iprot.readStructEnd()
20825 
 
20826 
  def write(self, oprot):
20827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20829 
      return
20830 
    oprot.writeStructBegin('addAmazonItem_args')
20831 
    if self.amazonlisted is not None:
20832 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20833 
      self.amazonlisted.write(oprot)
20834 
      oprot.writeFieldEnd()
20835 
    oprot.writeFieldStop()
20836 
    oprot.writeStructEnd()
20837 
 
20838 
  def validate(self):
20839 
    return
20840 
 
20841 
 
20842 
  def __repr__(self):
20843 
    L = ['%s=%r' % (key, value)
20844 
      for key, value in self.__dict__.iteritems()]
20845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20846 
 
20847 
  def __eq__(self, other):
20848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20849 
 
20850 
  def __ne__(self, other):
20851 
    return not (self == other)
20852 
 
20853 
class addAmazonItem_result:
20854 
 
20855 
  thrift_spec = (
20856 
  )
20857 
 
20858 
  def read(self, iprot):
20859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20861 
      return
20862 
    iprot.readStructBegin()
20863 
    while True:
20864 
      (fname, ftype, fid) = iprot.readFieldBegin()
20865 
      if ftype == TType.STOP:
20866 
        break
20867 
      else:
20868 
        iprot.skip(ftype)
20869 
      iprot.readFieldEnd()
20870 
    iprot.readStructEnd()
20871 
 
20872 
  def write(self, oprot):
20873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20875 
      return
20876 
    oprot.writeStructBegin('addAmazonItem_result')
20877 
    oprot.writeFieldStop()
20878 
    oprot.writeStructEnd()
20879 
 
20880 
  def validate(self):
20881 
    return
20882 
 
20883 
 
20884 
  def __repr__(self):
20885 
    L = ['%s=%r' % (key, value)
20886 
      for key, value in self.__dict__.iteritems()]
20887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20888 
 
20889 
  def __eq__(self, other):
20890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20891 
 
20892 
  def __ne__(self, other):
20893 
    return not (self == other)
7291 vikram.rag 20894 
 
20895 
class getAsinItems_args:
20896 
 
20897 
  thrift_spec = (
20898 
  )
20899 
 
20900 
  def read(self, iprot):
20901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20903 
      return
20904 
    iprot.readStructBegin()
20905 
    while True:
20906 
      (fname, ftype, fid) = iprot.readFieldBegin()
20907 
      if ftype == TType.STOP:
20908 
        break
20909 
      else:
20910 
        iprot.skip(ftype)
20911 
      iprot.readFieldEnd()
20912 
    iprot.readStructEnd()
20913 
 
20914 
  def write(self, oprot):
20915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20917 
      return
20918 
    oprot.writeStructBegin('getAsinItems_args')
20919 
    oprot.writeFieldStop()
20920 
    oprot.writeStructEnd()
20921 
 
20922 
  def validate(self):
20923 
    return
20924 
 
20925 
 
20926 
  def __repr__(self):
20927 
    L = ['%s=%r' % (key, value)
20928 
      for key, value in self.__dict__.iteritems()]
20929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20930 
 
20931 
  def __eq__(self, other):
20932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20933 
 
20934 
  def __ne__(self, other):
20935 
    return not (self == other)
20936 
 
20937 
class getAsinItems_result:
20938 
  """
20939 
  Attributes:
20940 
   - success
20941 
  """
20942 
 
20943 
  thrift_spec = (
20944 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20945 
  )
20946 
 
20947 
  def __init__(self, success=None,):
20948 
    self.success = success
20949 
 
20950 
  def read(self, iprot):
20951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20953 
      return
20954 
    iprot.readStructBegin()
20955 
    while True:
20956 
      (fname, ftype, fid) = iprot.readFieldBegin()
20957 
      if ftype == TType.STOP:
20958 
        break
20959 
      if fid == 0:
20960 
        if ftype == TType.LIST:
20961 
          self.success = []
9155 kshitij.so 20962 
          (_etype442, _size439) = iprot.readListBegin()
20963 
          for _i443 in xrange(_size439):
20964 
            _elem444 = Item()
20965 
            _elem444.read(iprot)
20966 
            self.success.append(_elem444)
7291 vikram.rag 20967 
          iprot.readListEnd()
20968 
        else:
20969 
          iprot.skip(ftype)
20970 
      else:
20971 
        iprot.skip(ftype)
20972 
      iprot.readFieldEnd()
20973 
    iprot.readStructEnd()
20974 
 
20975 
  def write(self, oprot):
20976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20978 
      return
20979 
    oprot.writeStructBegin('getAsinItems_result')
20980 
    if self.success is not None:
20981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20983 
      for iter445 in self.success:
20984 
        iter445.write(oprot)
7291 vikram.rag 20985 
      oprot.writeListEnd()
20986 
      oprot.writeFieldEnd()
20987 
    oprot.writeFieldStop()
20988 
    oprot.writeStructEnd()
20989 
 
20990 
  def validate(self):
20991 
    return
20992 
 
20993 
 
20994 
  def __repr__(self):
20995 
    L = ['%s=%r' % (key, value)
20996 
      for key, value in self.__dict__.iteritems()]
20997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20998 
 
20999 
  def __eq__(self, other):
21000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21001 
 
21002 
  def __ne__(self, other):
21003 
    return not (self == other)
21004 
 
21005 
class getAllFbaListedItems_args:
21006 
 
21007 
  thrift_spec = (
21008 
  )
21009 
 
21010 
  def read(self, iprot):
21011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21013 
      return
21014 
    iprot.readStructBegin()
21015 
    while True:
21016 
      (fname, ftype, fid) = iprot.readFieldBegin()
21017 
      if ftype == TType.STOP:
21018 
        break
21019 
      else:
21020 
        iprot.skip(ftype)
21021 
      iprot.readFieldEnd()
21022 
    iprot.readStructEnd()
21023 
 
21024 
  def write(self, oprot):
21025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21027 
      return
21028 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21029 
    oprot.writeFieldStop()
21030 
    oprot.writeStructEnd()
21031 
 
21032 
  def validate(self):
21033 
    return
21034 
 
21035 
 
21036 
  def __repr__(self):
21037 
    L = ['%s=%r' % (key, value)
21038 
      for key, value in self.__dict__.iteritems()]
21039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21040 
 
21041 
  def __eq__(self, other):
21042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21043 
 
21044 
  def __ne__(self, other):
21045 
    return not (self == other)
21046 
 
21047 
class getAllFbaListedItems_result:
21048 
  """
21049 
  Attributes:
21050 
   - success
21051 
  """
21052 
 
21053 
  thrift_spec = (
21054 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21055 
  )
21056 
 
21057 
  def __init__(self, success=None,):
21058 
    self.success = success
21059 
 
21060 
  def read(self, iprot):
21061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21063 
      return
21064 
    iprot.readStructBegin()
21065 
    while True:
21066 
      (fname, ftype, fid) = iprot.readFieldBegin()
21067 
      if ftype == TType.STOP:
21068 
        break
21069 
      if fid == 0:
21070 
        if ftype == TType.LIST:
21071 
          self.success = []
9155 kshitij.so 21072 
          (_etype449, _size446) = iprot.readListBegin()
21073 
          for _i450 in xrange(_size446):
21074 
            _elem451 = Amazonlisted()
21075 
            _elem451.read(iprot)
21076 
            self.success.append(_elem451)
7291 vikram.rag 21077 
          iprot.readListEnd()
21078 
        else:
21079 
          iprot.skip(ftype)
21080 
      else:
21081 
        iprot.skip(ftype)
21082 
      iprot.readFieldEnd()
21083 
    iprot.readStructEnd()
21084 
 
21085 
  def write(self, oprot):
21086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21088 
      return
21089 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21090 
    if self.success is not None:
21091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21093 
      for iter452 in self.success:
21094 
        iter452.write(oprot)
7291 vikram.rag 21095 
      oprot.writeListEnd()
21096 
      oprot.writeFieldEnd()
21097 
    oprot.writeFieldStop()
21098 
    oprot.writeStructEnd()
21099 
 
21100 
  def validate(self):
21101 
    return
21102 
 
21103 
 
21104 
  def __repr__(self):
21105 
    L = ['%s=%r' % (key, value)
21106 
      for key, value in self.__dict__.iteritems()]
21107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21108 
 
21109 
  def __eq__(self, other):
21110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21111 
 
21112 
  def __ne__(self, other):
21113 
    return not (self == other)
21114 
 
21115 
class getAllNonFbaListedItems_args:
21116 
 
21117 
  thrift_spec = (
21118 
  )
21119 
 
21120 
  def read(self, iprot):
21121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21123 
      return
21124 
    iprot.readStructBegin()
21125 
    while True:
21126 
      (fname, ftype, fid) = iprot.readFieldBegin()
21127 
      if ftype == TType.STOP:
21128 
        break
21129 
      else:
21130 
        iprot.skip(ftype)
21131 
      iprot.readFieldEnd()
21132 
    iprot.readStructEnd()
21133 
 
21134 
  def write(self, oprot):
21135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21137 
      return
21138 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21139 
    oprot.writeFieldStop()
21140 
    oprot.writeStructEnd()
21141 
 
21142 
  def validate(self):
21143 
    return
21144 
 
21145 
 
21146 
  def __repr__(self):
21147 
    L = ['%s=%r' % (key, value)
21148 
      for key, value in self.__dict__.iteritems()]
21149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21150 
 
21151 
  def __eq__(self, other):
21152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21153 
 
21154 
  def __ne__(self, other):
21155 
    return not (self == other)
21156 
 
21157 
class getAllNonFbaListedItems_result:
21158 
  """
21159 
  Attributes:
21160 
   - success
21161 
  """
21162 
 
21163 
  thrift_spec = (
21164 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21165 
  )
21166 
 
21167 
  def __init__(self, success=None,):
21168 
    self.success = success
21169 
 
21170 
  def read(self, iprot):
21171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21173 
      return
21174 
    iprot.readStructBegin()
21175 
    while True:
21176 
      (fname, ftype, fid) = iprot.readFieldBegin()
21177 
      if ftype == TType.STOP:
21178 
        break
21179 
      if fid == 0:
21180 
        if ftype == TType.LIST:
21181 
          self.success = []
9155 kshitij.so 21182 
          (_etype456, _size453) = iprot.readListBegin()
21183 
          for _i457 in xrange(_size453):
21184 
            _elem458 = Amazonlisted()
21185 
            _elem458.read(iprot)
21186 
            self.success.append(_elem458)
7291 vikram.rag 21187 
          iprot.readListEnd()
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      else:
21191 
        iprot.skip(ftype)
21192 
      iprot.readFieldEnd()
21193 
    iprot.readStructEnd()
21194 
 
21195 
  def write(self, oprot):
21196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21198 
      return
21199 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21200 
    if self.success is not None:
21201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21203 
      for iter459 in self.success:
21204 
        iter459.write(oprot)
7291 vikram.rag 21205 
      oprot.writeListEnd()
21206 
      oprot.writeFieldEnd()
21207 
    oprot.writeFieldStop()
21208 
    oprot.writeStructEnd()
21209 
 
21210 
  def validate(self):
21211 
    return
21212 
 
21213 
 
21214 
  def __repr__(self):
21215 
    L = ['%s=%r' % (key, value)
21216 
      for key, value in self.__dict__.iteritems()]
21217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21218 
 
21219 
  def __eq__(self, other):
21220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21221 
 
21222 
  def __ne__(self, other):
21223 
    return not (self == other)
7460 kshitij.so 21224 
 
21225 
class updateItemInventory_args:
21226 
  """
21227 
  Attributes:
21228 
   - itemId
21229 
   - holdInventory
21230 
   - defaultInventory
21231 
  """
21232 
 
21233 
  thrift_spec = (
21234 
    None, # 0
21235 
    (1, TType.I64, 'itemId', None, None, ), # 1
21236 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21237 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21238 
  )
21239 
 
21240 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21241 
    self.itemId = itemId
21242 
    self.holdInventory = holdInventory
21243 
    self.defaultInventory = defaultInventory
21244 
 
21245 
  def read(self, iprot):
21246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21248 
      return
21249 
    iprot.readStructBegin()
21250 
    while True:
21251 
      (fname, ftype, fid) = iprot.readFieldBegin()
21252 
      if ftype == TType.STOP:
21253 
        break
21254 
      if fid == 1:
21255 
        if ftype == TType.I64:
21256 
          self.itemId = iprot.readI64();
21257 
        else:
21258 
          iprot.skip(ftype)
21259 
      elif fid == 2:
21260 
        if ftype == TType.I64:
21261 
          self.holdInventory = iprot.readI64();
21262 
        else:
21263 
          iprot.skip(ftype)
21264 
      elif fid == 3:
21265 
        if ftype == TType.I64:
21266 
          self.defaultInventory = iprot.readI64();
21267 
        else:
21268 
          iprot.skip(ftype)
21269 
      else:
21270 
        iprot.skip(ftype)
21271 
      iprot.readFieldEnd()
21272 
    iprot.readStructEnd()
21273 
 
21274 
  def write(self, oprot):
21275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21277 
      return
21278 
    oprot.writeStructBegin('updateItemInventory_args')
21279 
    if self.itemId is not None:
21280 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21281 
      oprot.writeI64(self.itemId)
21282 
      oprot.writeFieldEnd()
21283 
    if self.holdInventory is not None:
21284 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21285 
      oprot.writeI64(self.holdInventory)
21286 
      oprot.writeFieldEnd()
21287 
    if self.defaultInventory is not None:
21288 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21289 
      oprot.writeI64(self.defaultInventory)
21290 
      oprot.writeFieldEnd()
21291 
    oprot.writeFieldStop()
21292 
    oprot.writeStructEnd()
21293 
 
21294 
  def validate(self):
21295 
    return
21296 
 
21297 
 
21298 
  def __repr__(self):
21299 
    L = ['%s=%r' % (key, value)
21300 
      for key, value in self.__dict__.iteritems()]
21301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21302 
 
21303 
  def __eq__(self, other):
21304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21305 
 
21306 
  def __ne__(self, other):
21307 
    return not (self == other)
21308 
 
21309 
class updateItemInventory_result:
21310 
  """
21311 
  Attributes:
21312 
   - success
21313 
  """
21314 
 
21315 
  thrift_spec = (
21316 
    (0, TType.BOOL, 'success', None, None, ), # 0
21317 
  )
21318 
 
21319 
  def __init__(self, success=None,):
21320 
    self.success = success
21321 
 
21322 
  def read(self, iprot):
21323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21325 
      return
21326 
    iprot.readStructBegin()
21327 
    while True:
21328 
      (fname, ftype, fid) = iprot.readFieldBegin()
21329 
      if ftype == TType.STOP:
21330 
        break
21331 
      if fid == 0:
21332 
        if ftype == TType.BOOL:
21333 
          self.success = iprot.readBool();
21334 
        else:
21335 
          iprot.skip(ftype)
21336 
      else:
21337 
        iprot.skip(ftype)
21338 
      iprot.readFieldEnd()
21339 
    iprot.readStructEnd()
21340 
 
21341 
  def write(self, oprot):
21342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21344 
      return
21345 
    oprot.writeStructBegin('updateItemInventory_result')
21346 
    if self.success is not None:
21347 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21348 
      oprot.writeBool(self.success)
21349 
      oprot.writeFieldEnd()
21350 
    oprot.writeFieldStop()
21351 
    oprot.writeStructEnd()
21352 
 
21353 
  def validate(self):
21354 
    return
21355 
 
21356 
 
21357 
  def __repr__(self):
21358 
    L = ['%s=%r' % (key, value)
21359 
      for key, value in self.__dict__.iteritems()]
21360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21361 
 
21362 
  def __eq__(self, other):
21363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21364 
 
21365 
  def __ne__(self, other):
21366 
    return not (self == other)
7770 kshitij.so 21367 
 
21368 
class updateTimestampForAmazonFeeds_args:
21369 
  """
21370 
  Attributes:
21371 
   - type
21372 
   - sku
21373 
   - timestamp
21374 
  """
21375 
 
21376 
  thrift_spec = (
21377 
    None, # 0
21378 
    (1, TType.STRING, 'type', None, None, ), # 1
21379 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21380 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21381 
  )
21382 
 
21383 
  def __init__(self, type=None, sku=None, timestamp=None,):
21384 
    self.type = type
21385 
    self.sku = sku
21386 
    self.timestamp = timestamp
21387 
 
21388 
  def read(self, iprot):
21389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21391 
      return
21392 
    iprot.readStructBegin()
21393 
    while True:
21394 
      (fname, ftype, fid) = iprot.readFieldBegin()
21395 
      if ftype == TType.STOP:
21396 
        break
21397 
      if fid == 1:
21398 
        if ftype == TType.STRING:
21399 
          self.type = iprot.readString();
21400 
        else:
21401 
          iprot.skip(ftype)
21402 
      elif fid == 2:
21403 
        if ftype == TType.LIST:
21404 
          self.sku = []
9155 kshitij.so 21405 
          (_etype463, _size460) = iprot.readListBegin()
21406 
          for _i464 in xrange(_size460):
21407 
            _elem465 = iprot.readI64();
21408 
            self.sku.append(_elem465)
7770 kshitij.so 21409 
          iprot.readListEnd()
21410 
        else:
21411 
          iprot.skip(ftype)
21412 
      elif fid == 3:
21413 
        if ftype == TType.I64:
21414 
          self.timestamp = iprot.readI64();
21415 
        else:
21416 
          iprot.skip(ftype)
21417 
      else:
21418 
        iprot.skip(ftype)
21419 
      iprot.readFieldEnd()
21420 
    iprot.readStructEnd()
21421 
 
21422 
  def write(self, oprot):
21423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21425 
      return
21426 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21427 
    if self.type is not None:
21428 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21429 
      oprot.writeString(self.type)
21430 
      oprot.writeFieldEnd()
21431 
    if self.sku is not None:
21432 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21433 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21434 
      for iter466 in self.sku:
21435 
        oprot.writeI64(iter466)
7770 kshitij.so 21436 
      oprot.writeListEnd()
21437 
      oprot.writeFieldEnd()
21438 
    if self.timestamp is not None:
21439 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21440 
      oprot.writeI64(self.timestamp)
21441 
      oprot.writeFieldEnd()
21442 
    oprot.writeFieldStop()
21443 
    oprot.writeStructEnd()
21444 
 
21445 
  def validate(self):
21446 
    return
21447 
 
21448 
 
21449 
  def __repr__(self):
21450 
    L = ['%s=%r' % (key, value)
21451 
      for key, value in self.__dict__.iteritems()]
21452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21453 
 
21454 
  def __eq__(self, other):
21455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21456 
 
21457 
  def __ne__(self, other):
21458 
    return not (self == other)
21459 
 
21460 
class updateTimestampForAmazonFeeds_result:
21461 
  """
21462 
  Attributes:
21463 
   - success
21464 
  """
21465 
 
21466 
  thrift_spec = (
21467 
    (0, TType.BOOL, 'success', None, None, ), # 0
21468 
  )
21469 
 
21470 
  def __init__(self, success=None,):
21471 
    self.success = success
21472 
 
21473 
  def read(self, iprot):
21474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21476 
      return
21477 
    iprot.readStructBegin()
21478 
    while True:
21479 
      (fname, ftype, fid) = iprot.readFieldBegin()
21480 
      if ftype == TType.STOP:
21481 
        break
21482 
      if fid == 0:
21483 
        if ftype == TType.BOOL:
21484 
          self.success = iprot.readBool();
21485 
        else:
21486 
          iprot.skip(ftype)
21487 
      else:
21488 
        iprot.skip(ftype)
21489 
      iprot.readFieldEnd()
21490 
    iprot.readStructEnd()
21491 
 
21492 
  def write(self, oprot):
21493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21495 
      return
21496 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21497 
    if self.success is not None:
21498 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21499 
      oprot.writeBool(self.success)
21500 
      oprot.writeFieldEnd()
21501 
    oprot.writeFieldStop()
21502 
    oprot.writeStructEnd()
21503 
 
21504 
  def validate(self):
21505 
    return
21506 
 
21507 
 
21508 
  def __repr__(self):
21509 
    L = ['%s=%r' % (key, value)
21510 
      for key, value in self.__dict__.iteritems()]
21511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21512 
 
21513 
  def __eq__(self, other):
21514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21515 
 
21516 
  def __ne__(self, other):
21517 
    return not (self == other)
7897 amar.kumar 21518 
 
21519 
class getAllParentCategories_args:
21520 
 
21521 
  thrift_spec = (
21522 
  )
21523 
 
21524 
  def read(self, iprot):
21525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21527 
      return
21528 
    iprot.readStructBegin()
21529 
    while True:
21530 
      (fname, ftype, fid) = iprot.readFieldBegin()
21531 
      if ftype == TType.STOP:
21532 
        break
21533 
      else:
21534 
        iprot.skip(ftype)
21535 
      iprot.readFieldEnd()
21536 
    iprot.readStructEnd()
21537 
 
21538 
  def write(self, oprot):
21539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21541 
      return
21542 
    oprot.writeStructBegin('getAllParentCategories_args')
21543 
    oprot.writeFieldStop()
21544 
    oprot.writeStructEnd()
21545 
 
21546 
  def validate(self):
21547 
    return
21548 
 
21549 
 
21550 
  def __repr__(self):
21551 
    L = ['%s=%r' % (key, value)
21552 
      for key, value in self.__dict__.iteritems()]
21553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21554 
 
21555 
  def __eq__(self, other):
21556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21557 
 
21558 
  def __ne__(self, other):
21559 
    return not (self == other)
21560 
 
21561 
class getAllParentCategories_result:
21562 
  """
21563 
  Attributes:
21564 
   - success
21565 
  """
21566 
 
21567 
  thrift_spec = (
21568 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21569 
  )
21570 
 
21571 
  def __init__(self, success=None,):
21572 
    self.success = success
21573 
 
21574 
  def read(self, iprot):
21575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21577 
      return
21578 
    iprot.readStructBegin()
21579 
    while True:
21580 
      (fname, ftype, fid) = iprot.readFieldBegin()
21581 
      if ftype == TType.STOP:
21582 
        break
21583 
      if fid == 0:
21584 
        if ftype == TType.LIST:
21585 
          self.success = []
9155 kshitij.so 21586 
          (_etype470, _size467) = iprot.readListBegin()
21587 
          for _i471 in xrange(_size467):
21588 
            _elem472 = Category()
21589 
            _elem472.read(iprot)
21590 
            self.success.append(_elem472)
7897 amar.kumar 21591 
          iprot.readListEnd()
21592 
        else:
21593 
          iprot.skip(ftype)
21594 
      else:
21595 
        iprot.skip(ftype)
21596 
      iprot.readFieldEnd()
21597 
    iprot.readStructEnd()
21598 
 
21599 
  def write(self, oprot):
21600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21602 
      return
21603 
    oprot.writeStructBegin('getAllParentCategories_result')
21604 
    if self.success is not None:
21605 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21606 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21607 
      for iter473 in self.success:
21608 
        iter473.write(oprot)
7897 amar.kumar 21609 
      oprot.writeListEnd()
21610 
      oprot.writeFieldEnd()
21611 
    oprot.writeFieldStop()
21612 
    oprot.writeStructEnd()
21613 
 
21614 
  def validate(self):
21615 
    return
21616 
 
21617 
 
21618 
  def __repr__(self):
21619 
    L = ['%s=%r' % (key, value)
21620 
      for key, value in self.__dict__.iteritems()]
21621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21622 
 
21623 
  def __eq__(self, other):
21624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21625 
 
21626 
  def __ne__(self, other):
21627 
    return not (self == other)
7977 kshitij.so 21628 
 
21629 
class addPageViewEvent_args:
21630 
  """
21631 
  Attributes:
21632 
   - pageViewEvents
21633 
  """
21634 
 
21635 
  thrift_spec = (
21636 
    None, # 0
21637 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21638 
  )
21639 
 
21640 
  def __init__(self, pageViewEvents=None,):
21641 
    self.pageViewEvents = pageViewEvents
21642 
 
21643 
  def read(self, iprot):
21644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21646 
      return
21647 
    iprot.readStructBegin()
21648 
    while True:
21649 
      (fname, ftype, fid) = iprot.readFieldBegin()
21650 
      if ftype == TType.STOP:
21651 
        break
21652 
      if fid == 1:
21653 
        if ftype == TType.STRUCT:
21654 
          self.pageViewEvents = PageViewEvents()
21655 
          self.pageViewEvents.read(iprot)
21656 
        else:
21657 
          iprot.skip(ftype)
21658 
      else:
21659 
        iprot.skip(ftype)
21660 
      iprot.readFieldEnd()
21661 
    iprot.readStructEnd()
21662 
 
21663 
  def write(self, oprot):
21664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21666 
      return
21667 
    oprot.writeStructBegin('addPageViewEvent_args')
21668 
    if self.pageViewEvents is not None:
21669 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21670 
      self.pageViewEvents.write(oprot)
21671 
      oprot.writeFieldEnd()
21672 
    oprot.writeFieldStop()
21673 
    oprot.writeStructEnd()
21674 
 
21675 
  def validate(self):
21676 
    return
21677 
 
21678 
 
21679 
  def __repr__(self):
21680 
    L = ['%s=%r' % (key, value)
21681 
      for key, value in self.__dict__.iteritems()]
21682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21683 
 
21684 
  def __eq__(self, other):
21685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21686 
 
21687 
  def __ne__(self, other):
21688 
    return not (self == other)
21689 
 
21690 
class addPageViewEvent_result:
21691 
 
21692 
  thrift_spec = (
21693 
  )
21694 
 
21695 
  def read(self, iprot):
21696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21698 
      return
21699 
    iprot.readStructBegin()
21700 
    while True:
21701 
      (fname, ftype, fid) = iprot.readFieldBegin()
21702 
      if ftype == TType.STOP:
21703 
        break
21704 
      else:
21705 
        iprot.skip(ftype)
21706 
      iprot.readFieldEnd()
21707 
    iprot.readStructEnd()
21708 
 
21709 
  def write(self, oprot):
21710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21712 
      return
21713 
    oprot.writeStructBegin('addPageViewEvent_result')
21714 
    oprot.writeFieldStop()
21715 
    oprot.writeStructEnd()
21716 
 
21717 
  def validate(self):
21718 
    return
21719 
 
21720 
 
21721 
  def __repr__(self):
21722 
    L = ['%s=%r' % (key, value)
21723 
      for key, value in self.__dict__.iteritems()]
21724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21725 
 
21726 
  def __eq__(self, other):
21727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21728 
 
21729 
  def __ne__(self, other):
21730 
    return not (self == other)
21731 
 
21732 
class addCartEvent_args:
21733 
  """
21734 
  Attributes:
21735 
   - cartEvents
21736 
  """
21737 
 
21738 
  thrift_spec = (
21739 
    None, # 0
21740 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21741 
  )
21742 
 
21743 
  def __init__(self, cartEvents=None,):
21744 
    self.cartEvents = cartEvents
21745 
 
21746 
  def read(self, iprot):
21747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21749 
      return
21750 
    iprot.readStructBegin()
21751 
    while True:
21752 
      (fname, ftype, fid) = iprot.readFieldBegin()
21753 
      if ftype == TType.STOP:
21754 
        break
21755 
      if fid == 1:
21756 
        if ftype == TType.STRUCT:
21757 
          self.cartEvents = CartEvents()
21758 
          self.cartEvents.read(iprot)
21759 
        else:
21760 
          iprot.skip(ftype)
21761 
      else:
21762 
        iprot.skip(ftype)
21763 
      iprot.readFieldEnd()
21764 
    iprot.readStructEnd()
21765 
 
21766 
  def write(self, oprot):
21767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21769 
      return
21770 
    oprot.writeStructBegin('addCartEvent_args')
21771 
    if self.cartEvents is not None:
21772 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21773 
      self.cartEvents.write(oprot)
21774 
      oprot.writeFieldEnd()
21775 
    oprot.writeFieldStop()
21776 
    oprot.writeStructEnd()
21777 
 
21778 
  def validate(self):
21779 
    return
21780 
 
21781 
 
21782 
  def __repr__(self):
21783 
    L = ['%s=%r' % (key, value)
21784 
      for key, value in self.__dict__.iteritems()]
21785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21786 
 
21787 
  def __eq__(self, other):
21788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21789 
 
21790 
  def __ne__(self, other):
21791 
    return not (self == other)
21792 
 
21793 
class addCartEvent_result:
21794 
 
21795 
  thrift_spec = (
21796 
  )
21797 
 
21798 
  def read(self, iprot):
21799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21801 
      return
21802 
    iprot.readStructBegin()
21803 
    while True:
21804 
      (fname, ftype, fid) = iprot.readFieldBegin()
21805 
      if ftype == TType.STOP:
21806 
        break
21807 
      else:
21808 
        iprot.skip(ftype)
21809 
      iprot.readFieldEnd()
21810 
    iprot.readStructEnd()
21811 
 
21812 
  def write(self, oprot):
21813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21815 
      return
21816 
    oprot.writeStructBegin('addCartEvent_result')
21817 
    oprot.writeFieldStop()
21818 
    oprot.writeStructEnd()
21819 
 
21820 
  def validate(self):
21821 
    return
21822 
 
21823 
 
21824 
  def __repr__(self):
21825 
    L = ['%s=%r' % (key, value)
21826 
      for key, value in self.__dict__.iteritems()]
21827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21828 
 
21829 
  def __eq__(self, other):
21830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21831 
 
21832 
  def __ne__(self, other):
21833 
    return not (self == other)
8139 kshitij.so 21834 
 
8182 amar.kumar 21835 
class addEbayItem_args:
21836 
  """
21837 
  Attributes:
21838 
   - ebayItem
21839 
  """
21840 
 
21841 
  thrift_spec = (
21842 
    None, # 0
21843 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21844 
  )
21845 
 
21846 
  def __init__(self, ebayItem=None,):
21847 
    self.ebayItem = ebayItem
21848 
 
21849 
  def read(self, iprot):
21850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21852 
      return
21853 
    iprot.readStructBegin()
21854 
    while True:
21855 
      (fname, ftype, fid) = iprot.readFieldBegin()
21856 
      if ftype == TType.STOP:
21857 
        break
21858 
      if fid == 1:
21859 
        if ftype == TType.STRUCT:
21860 
          self.ebayItem = EbayItem()
21861 
          self.ebayItem.read(iprot)
21862 
        else:
21863 
          iprot.skip(ftype)
21864 
      else:
21865 
        iprot.skip(ftype)
21866 
      iprot.readFieldEnd()
21867 
    iprot.readStructEnd()
21868 
 
21869 
  def write(self, oprot):
21870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21872 
      return
21873 
    oprot.writeStructBegin('addEbayItem_args')
21874 
    if self.ebayItem is not None:
21875 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21876 
      self.ebayItem.write(oprot)
21877 
      oprot.writeFieldEnd()
21878 
    oprot.writeFieldStop()
21879 
    oprot.writeStructEnd()
21880 
 
21881 
  def validate(self):
21882 
    return
21883 
 
21884 
 
21885 
  def __repr__(self):
21886 
    L = ['%s=%r' % (key, value)
21887 
      for key, value in self.__dict__.iteritems()]
21888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21889 
 
21890 
  def __eq__(self, other):
21891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21892 
 
21893 
  def __ne__(self, other):
21894 
    return not (self == other)
21895 
 
21896 
class addEbayItem_result:
21897 
 
21898 
  thrift_spec = (
21899 
  )
21900 
 
21901 
  def read(self, iprot):
21902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21904 
      return
21905 
    iprot.readStructBegin()
21906 
    while True:
21907 
      (fname, ftype, fid) = iprot.readFieldBegin()
21908 
      if ftype == TType.STOP:
21909 
        break
21910 
      else:
21911 
        iprot.skip(ftype)
21912 
      iprot.readFieldEnd()
21913 
    iprot.readStructEnd()
21914 
 
21915 
  def write(self, oprot):
21916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21918 
      return
21919 
    oprot.writeStructBegin('addEbayItem_result')
21920 
    oprot.writeFieldStop()
21921 
    oprot.writeStructEnd()
21922 
 
21923 
  def validate(self):
21924 
    return
21925 
 
21926 
 
21927 
  def __repr__(self):
21928 
    L = ['%s=%r' % (key, value)
21929 
      for key, value in self.__dict__.iteritems()]
21930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21931 
 
21932 
  def __eq__(self, other):
21933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21934 
 
21935 
  def __ne__(self, other):
21936 
    return not (self == other)
21937 
 
21938 
class getEbayItem_args:
21939 
  """
21940 
  Attributes:
21941 
   - listingId
21942 
  """
21943 
 
21944 
  thrift_spec = (
21945 
    None, # 0
21946 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21947 
  )
21948 
 
21949 
  def __init__(self, listingId=None,):
21950 
    self.listingId = listingId
21951 
 
21952 
  def read(self, iprot):
21953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21955 
      return
21956 
    iprot.readStructBegin()
21957 
    while True:
21958 
      (fname, ftype, fid) = iprot.readFieldBegin()
21959 
      if ftype == TType.STOP:
21960 
        break
21961 
      if fid == 1:
21962 
        if ftype == TType.STRING:
21963 
          self.listingId = iprot.readString();
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      else:
21967 
        iprot.skip(ftype)
21968 
      iprot.readFieldEnd()
21969 
    iprot.readStructEnd()
21970 
 
21971 
  def write(self, oprot):
21972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21974 
      return
21975 
    oprot.writeStructBegin('getEbayItem_args')
21976 
    if self.listingId is not None:
21977 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21978 
      oprot.writeString(self.listingId)
21979 
      oprot.writeFieldEnd()
21980 
    oprot.writeFieldStop()
21981 
    oprot.writeStructEnd()
21982 
 
21983 
  def validate(self):
21984 
    return
21985 
 
21986 
 
21987 
  def __repr__(self):
21988 
    L = ['%s=%r' % (key, value)
21989 
      for key, value in self.__dict__.iteritems()]
21990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21991 
 
21992 
  def __eq__(self, other):
21993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21994 
 
21995 
  def __ne__(self, other):
21996 
    return not (self == other)
21997 
 
21998 
class getEbayItem_result:
21999 
  """
22000 
  Attributes:
22001 
   - success
22002 
  """
22003 
 
22004 
  thrift_spec = (
22005 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22006 
  )
22007 
 
22008 
  def __init__(self, success=None,):
22009 
    self.success = success
22010 
 
22011 
  def read(self, iprot):
22012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22014 
      return
22015 
    iprot.readStructBegin()
22016 
    while True:
22017 
      (fname, ftype, fid) = iprot.readFieldBegin()
22018 
      if ftype == TType.STOP:
22019 
        break
22020 
      if fid == 0:
22021 
        if ftype == TType.STRUCT:
22022 
          self.success = EbayItem()
22023 
          self.success.read(iprot)
22024 
        else:
22025 
          iprot.skip(ftype)
22026 
      else:
22027 
        iprot.skip(ftype)
22028 
      iprot.readFieldEnd()
22029 
    iprot.readStructEnd()
22030 
 
22031 
  def write(self, oprot):
22032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22034 
      return
22035 
    oprot.writeStructBegin('getEbayItem_result')
22036 
    if self.success is not None:
22037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22038 
      self.success.write(oprot)
22039 
      oprot.writeFieldEnd()
22040 
    oprot.writeFieldStop()
22041 
    oprot.writeStructEnd()
22042 
 
22043 
  def validate(self):
22044 
    return
22045 
 
22046 
 
22047 
  def __repr__(self):
22048 
    L = ['%s=%r' % (key, value)
22049 
      for key, value in self.__dict__.iteritems()]
22050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22051 
 
22052 
  def __eq__(self, other):
22053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22054 
 
22055 
  def __ne__(self, other):
22056 
    return not (self == other)
22057 
 
22058 
class updateEbayItem_args:
22059 
  """
22060 
  Attributes:
22061 
   - ebayItem
22062 
  """
22063 
 
22064 
  thrift_spec = (
22065 
    None, # 0
22066 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22067 
  )
22068 
 
22069 
  def __init__(self, ebayItem=None,):
22070 
    self.ebayItem = ebayItem
22071 
 
22072 
  def read(self, iprot):
22073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22075 
      return
22076 
    iprot.readStructBegin()
22077 
    while True:
22078 
      (fname, ftype, fid) = iprot.readFieldBegin()
22079 
      if ftype == TType.STOP:
22080 
        break
22081 
      if fid == 1:
22082 
        if ftype == TType.STRUCT:
22083 
          self.ebayItem = EbayItem()
22084 
          self.ebayItem.read(iprot)
22085 
        else:
22086 
          iprot.skip(ftype)
22087 
      else:
22088 
        iprot.skip(ftype)
22089 
      iprot.readFieldEnd()
22090 
    iprot.readStructEnd()
22091 
 
22092 
  def write(self, oprot):
22093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22095 
      return
22096 
    oprot.writeStructBegin('updateEbayItem_args')
22097 
    if self.ebayItem is not None:
22098 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22099 
      self.ebayItem.write(oprot)
22100 
      oprot.writeFieldEnd()
22101 
    oprot.writeFieldStop()
22102 
    oprot.writeStructEnd()
22103 
 
22104 
  def validate(self):
22105 
    return
22106 
 
22107 
 
22108 
  def __repr__(self):
22109 
    L = ['%s=%r' % (key, value)
22110 
      for key, value in self.__dict__.iteritems()]
22111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22112 
 
22113 
  def __eq__(self, other):
22114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22115 
 
22116 
  def __ne__(self, other):
22117 
    return not (self == other)
22118 
 
22119 
class updateEbayItem_result:
22120 
 
22121 
  thrift_spec = (
22122 
  )
22123 
 
22124 
  def read(self, iprot):
22125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22127 
      return
22128 
    iprot.readStructBegin()
22129 
    while True:
22130 
      (fname, ftype, fid) = iprot.readFieldBegin()
22131 
      if ftype == TType.STOP:
22132 
        break
22133 
      else:
22134 
        iprot.skip(ftype)
22135 
      iprot.readFieldEnd()
22136 
    iprot.readStructEnd()
22137 
 
22138 
  def write(self, oprot):
22139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22141 
      return
22142 
    oprot.writeStructBegin('updateEbayItem_result')
22143 
    oprot.writeFieldStop()
22144 
    oprot.writeStructEnd()
22145 
 
22146 
  def validate(self):
22147 
    return
22148 
 
22149 
 
22150 
  def __repr__(self):
22151 
    L = ['%s=%r' % (key, value)
22152 
      for key, value in self.__dict__.iteritems()]
22153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22154 
 
22155 
  def __eq__(self, other):
22156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22157 
 
22158 
  def __ne__(self, other):
22159 
    return not (self == other)
22160 
 
8139 kshitij.so 22161 
class getAmazonListedItems_args:
22162 
  """
22163 
  Attributes:
22164 
   - offset
22165 
   - limit
22166 
  """
22167 
 
22168 
  thrift_spec = (
22169 
    None, # 0
22170 
    (1, TType.I64, 'offset', None, None, ), # 1
22171 
    (2, TType.I64, 'limit', None, None, ), # 2
22172 
  )
22173 
 
22174 
  def __init__(self, offset=None, limit=None,):
22175 
    self.offset = offset
22176 
    self.limit = limit
22177 
 
22178 
  def read(self, iprot):
22179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22181 
      return
22182 
    iprot.readStructBegin()
22183 
    while True:
22184 
      (fname, ftype, fid) = iprot.readFieldBegin()
22185 
      if ftype == TType.STOP:
22186 
        break
22187 
      if fid == 1:
22188 
        if ftype == TType.I64:
22189 
          self.offset = iprot.readI64();
22190 
        else:
22191 
          iprot.skip(ftype)
22192 
      elif fid == 2:
22193 
        if ftype == TType.I64:
22194 
          self.limit = iprot.readI64();
22195 
        else:
22196 
          iprot.skip(ftype)
22197 
      else:
22198 
        iprot.skip(ftype)
22199 
      iprot.readFieldEnd()
22200 
    iprot.readStructEnd()
22201 
 
22202 
  def write(self, oprot):
22203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22205 
      return
22206 
    oprot.writeStructBegin('getAmazonListedItems_args')
22207 
    if self.offset is not None:
22208 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22209 
      oprot.writeI64(self.offset)
22210 
      oprot.writeFieldEnd()
22211 
    if self.limit is not None:
22212 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22213 
      oprot.writeI64(self.limit)
22214 
      oprot.writeFieldEnd()
22215 
    oprot.writeFieldStop()
22216 
    oprot.writeStructEnd()
22217 
 
22218 
  def validate(self):
22219 
    return
22220 
 
22221 
 
22222 
  def __repr__(self):
22223 
    L = ['%s=%r' % (key, value)
22224 
      for key, value in self.__dict__.iteritems()]
22225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22226 
 
22227 
  def __eq__(self, other):
22228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22229 
 
22230 
  def __ne__(self, other):
22231 
    return not (self == other)
22232 
 
22233 
class getAmazonListedItems_result:
22234 
  """
22235 
  Attributes:
22236 
   - success
22237 
  """
22238 
 
22239 
  thrift_spec = (
22240 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22241 
  )
22242 
 
22243 
  def __init__(self, success=None,):
22244 
    self.success = success
22245 
 
22246 
  def read(self, iprot):
22247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22249 
      return
22250 
    iprot.readStructBegin()
22251 
    while True:
22252 
      (fname, ftype, fid) = iprot.readFieldBegin()
22253 
      if ftype == TType.STOP:
22254 
        break
22255 
      if fid == 0:
22256 
        if ftype == TType.LIST:
22257 
          self.success = []
9155 kshitij.so 22258 
          (_etype477, _size474) = iprot.readListBegin()
22259 
          for _i478 in xrange(_size474):
22260 
            _elem479 = Amazonlisted()
22261 
            _elem479.read(iprot)
22262 
            self.success.append(_elem479)
8139 kshitij.so 22263 
          iprot.readListEnd()
22264 
        else:
22265 
          iprot.skip(ftype)
22266 
      else:
22267 
        iprot.skip(ftype)
22268 
      iprot.readFieldEnd()
22269 
    iprot.readStructEnd()
22270 
 
22271 
  def write(self, oprot):
22272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22274 
      return
22275 
    oprot.writeStructBegin('getAmazonListedItems_result')
22276 
    if self.success is not None:
22277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22279 
      for iter480 in self.success:
22280 
        iter480.write(oprot)
8139 kshitij.so 22281 
      oprot.writeListEnd()
22282 
      oprot.writeFieldEnd()
22283 
    oprot.writeFieldStop()
22284 
    oprot.writeStructEnd()
22285 
 
22286 
  def validate(self):
22287 
    return
22288 
 
22289 
 
22290 
  def __repr__(self):
22291 
    L = ['%s=%r' % (key, value)
22292 
      for key, value in self.__dict__.iteritems()]
22293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22294 
 
22295 
  def __eq__(self, other):
22296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22297 
 
22298 
  def __ne__(self, other):
22299 
    return not (self == other)
8168 kshitij.so 22300 
 
22301 
class updateAmazonAttributesInBulk_args:
22302 
  """
22303 
  Attributes:
22304 
   - amazonlisted
22305 
  """
22306 
 
22307 
  thrift_spec = (
22308 
    None, # 0
22309 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22310 
  )
22311 
 
22312 
  def __init__(self, amazonlisted=None,):
22313 
    self.amazonlisted = amazonlisted
22314 
 
22315 
  def read(self, iprot):
22316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22318 
      return
22319 
    iprot.readStructBegin()
22320 
    while True:
22321 
      (fname, ftype, fid) = iprot.readFieldBegin()
22322 
      if ftype == TType.STOP:
22323 
        break
22324 
      if fid == 1:
22325 
        if ftype == TType.MAP:
22326 
          self.amazonlisted = {}
9155 kshitij.so 22327 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22328 
          for _i485 in xrange(_size481):
22329 
            _key486 = iprot.readI64();
22330 
            _val487 = Amazonlisted()
22331 
            _val487.read(iprot)
22332 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22333 
          iprot.readMapEnd()
22334 
        else:
22335 
          iprot.skip(ftype)
22336 
      else:
22337 
        iprot.skip(ftype)
22338 
      iprot.readFieldEnd()
22339 
    iprot.readStructEnd()
22340 
 
22341 
  def write(self, oprot):
22342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22344 
      return
22345 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22346 
    if self.amazonlisted is not None:
22347 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22348 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22349 
      for kiter488,viter489 in self.amazonlisted.items():
22350 
        oprot.writeI64(kiter488)
22351 
        viter489.write(oprot)
8168 kshitij.so 22352 
      oprot.writeMapEnd()
22353 
      oprot.writeFieldEnd()
22354 
    oprot.writeFieldStop()
22355 
    oprot.writeStructEnd()
22356 
 
22357 
  def validate(self):
22358 
    return
22359 
 
22360 
 
22361 
  def __repr__(self):
22362 
    L = ['%s=%r' % (key, value)
22363 
      for key, value in self.__dict__.iteritems()]
22364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22365 
 
22366 
  def __eq__(self, other):
22367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22368 
 
22369 
  def __ne__(self, other):
22370 
    return not (self == other)
22371 
 
22372 
class updateAmazonAttributesInBulk_result:
22373 
  """
22374 
  Attributes:
22375 
   - success
22376 
  """
22377 
 
22378 
  thrift_spec = (
22379 
    (0, TType.BOOL, 'success', None, None, ), # 0
22380 
  )
22381 
 
22382 
  def __init__(self, success=None,):
22383 
    self.success = success
22384 
 
22385 
  def read(self, iprot):
22386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22388 
      return
22389 
    iprot.readStructBegin()
22390 
    while True:
22391 
      (fname, ftype, fid) = iprot.readFieldBegin()
22392 
      if ftype == TType.STOP:
22393 
        break
22394 
      if fid == 0:
22395 
        if ftype == TType.BOOL:
22396 
          self.success = iprot.readBool();
22397 
        else:
22398 
          iprot.skip(ftype)
22399 
      else:
22400 
        iprot.skip(ftype)
22401 
      iprot.readFieldEnd()
22402 
    iprot.readStructEnd()
22403 
 
22404 
  def write(self, oprot):
22405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22407 
      return
22408 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22409 
    if self.success is not None:
22410 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22411 
      oprot.writeBool(self.success)
22412 
      oprot.writeFieldEnd()
22413 
    oprot.writeFieldStop()
22414 
    oprot.writeStructEnd()
22415 
 
22416 
  def validate(self):
22417 
    return
22418 
 
22419 
 
22420 
  def __repr__(self):
22421 
    L = ['%s=%r' % (key, value)
22422 
      for key, value in self.__dict__.iteritems()]
22423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22424 
 
22425 
  def __eq__(self, other):
22426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22427 
 
22428 
  def __ne__(self, other):
22429 
    return not (self == other)
8379 vikram.rag 22430 
 
22431 
class getAllItemstoListOnFba_args:
22432 
 
22433 
  thrift_spec = (
22434 
  )
22435 
 
22436 
  def read(self, iprot):
22437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22439 
      return
22440 
    iprot.readStructBegin()
22441 
    while True:
22442 
      (fname, ftype, fid) = iprot.readFieldBegin()
22443 
      if ftype == TType.STOP:
22444 
        break
22445 
      else:
22446 
        iprot.skip(ftype)
22447 
      iprot.readFieldEnd()
22448 
    iprot.readStructEnd()
22449 
 
22450 
  def write(self, oprot):
22451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22453 
      return
22454 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
22455 
    oprot.writeFieldStop()
22456 
    oprot.writeStructEnd()
22457 
 
22458 
  def validate(self):
22459 
    return
22460 
 
22461 
 
22462 
  def __repr__(self):
22463 
    L = ['%s=%r' % (key, value)
22464 
      for key, value in self.__dict__.iteritems()]
22465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22466 
 
22467 
  def __eq__(self, other):
22468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22469 
 
22470 
  def __ne__(self, other):
22471 
    return not (self == other)
22472 
 
22473 
class getAllItemstoListOnFba_result:
22474 
  """
22475 
  Attributes:
22476 
   - success
22477 
  """
22478 
 
22479 
  thrift_spec = (
22480 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22481 
  )
22482 
 
22483 
  def __init__(self, success=None,):
22484 
    self.success = success
22485 
 
22486 
  def read(self, iprot):
22487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22489 
      return
22490 
    iprot.readStructBegin()
22491 
    while True:
22492 
      (fname, ftype, fid) = iprot.readFieldBegin()
22493 
      if ftype == TType.STOP:
22494 
        break
22495 
      if fid == 0:
22496 
        if ftype == TType.LIST:
22497 
          self.success = []
9155 kshitij.so 22498 
          (_etype493, _size490) = iprot.readListBegin()
22499 
          for _i494 in xrange(_size490):
22500 
            _elem495 = Amazonlisted()
22501 
            _elem495.read(iprot)
22502 
            self.success.append(_elem495)
8379 vikram.rag 22503 
          iprot.readListEnd()
22504 
        else:
22505 
          iprot.skip(ftype)
22506 
      else:
22507 
        iprot.skip(ftype)
22508 
      iprot.readFieldEnd()
22509 
    iprot.readStructEnd()
22510 
 
22511 
  def write(self, oprot):
22512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22514 
      return
22515 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22516 
    if self.success is not None:
22517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22519 
      for iter496 in self.success:
22520 
        iter496.write(oprot)
8379 vikram.rag 22521 
      oprot.writeListEnd()
22522 
      oprot.writeFieldEnd()
22523 
    oprot.writeFieldStop()
22524 
    oprot.writeStructEnd()
22525 
 
22526 
  def validate(self):
22527 
    return
22528 
 
22529 
 
22530 
  def __repr__(self):
22531 
    L = ['%s=%r' % (key, value)
22532 
      for key, value in self.__dict__.iteritems()]
22533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22534 
 
22535 
  def __eq__(self, other):
22536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22537 
 
22538 
  def __ne__(self, other):
22539 
    return not (self == other)
22540 
 
22541 
class getAllItemstoListOnNonFba_args:
22542 
 
22543 
  thrift_spec = (
22544 
  )
22545 
 
22546 
  def read(self, iprot):
22547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22549 
      return
22550 
    iprot.readStructBegin()
22551 
    while True:
22552 
      (fname, ftype, fid) = iprot.readFieldBegin()
22553 
      if ftype == TType.STOP:
22554 
        break
22555 
      else:
22556 
        iprot.skip(ftype)
22557 
      iprot.readFieldEnd()
22558 
    iprot.readStructEnd()
22559 
 
22560 
  def write(self, oprot):
22561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22563 
      return
22564 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22565 
    oprot.writeFieldStop()
22566 
    oprot.writeStructEnd()
22567 
 
22568 
  def validate(self):
22569 
    return
22570 
 
22571 
 
22572 
  def __repr__(self):
22573 
    L = ['%s=%r' % (key, value)
22574 
      for key, value in self.__dict__.iteritems()]
22575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22576 
 
22577 
  def __eq__(self, other):
22578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22579 
 
22580 
  def __ne__(self, other):
22581 
    return not (self == other)
22582 
 
22583 
class getAllItemstoListOnNonFba_result:
22584 
  """
22585 
  Attributes:
22586 
   - success
22587 
  """
22588 
 
22589 
  thrift_spec = (
22590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22591 
  )
22592 
 
22593 
  def __init__(self, success=None,):
22594 
    self.success = success
22595 
 
22596 
  def read(self, iprot):
22597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22599 
      return
22600 
    iprot.readStructBegin()
22601 
    while True:
22602 
      (fname, ftype, fid) = iprot.readFieldBegin()
22603 
      if ftype == TType.STOP:
22604 
        break
22605 
      if fid == 0:
22606 
        if ftype == TType.LIST:
22607 
          self.success = []
9155 kshitij.so 22608 
          (_etype500, _size497) = iprot.readListBegin()
22609 
          for _i501 in xrange(_size497):
22610 
            _elem502 = Amazonlisted()
22611 
            _elem502.read(iprot)
22612 
            self.success.append(_elem502)
8379 vikram.rag 22613 
          iprot.readListEnd()
22614 
        else:
22615 
          iprot.skip(ftype)
22616 
      else:
22617 
        iprot.skip(ftype)
22618 
      iprot.readFieldEnd()
22619 
    iprot.readStructEnd()
22620 
 
22621 
  def write(self, oprot):
22622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22624 
      return
22625 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22626 
    if self.success is not None:
22627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22629 
      for iter503 in self.success:
22630 
        iter503.write(oprot)
8379 vikram.rag 22631 
      oprot.writeListEnd()
22632 
      oprot.writeFieldEnd()
22633 
    oprot.writeFieldStop()
22634 
    oprot.writeStructEnd()
22635 
 
22636 
  def validate(self):
22637 
    return
22638 
 
22639 
 
22640 
  def __repr__(self):
22641 
    L = ['%s=%r' % (key, value)
22642 
      for key, value in self.__dict__.iteritems()]
22643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22644 
 
22645 
  def __eq__(self, other):
22646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22647 
 
22648 
  def __ne__(self, other):
22649 
    return not (self == other)
8616 vikram.rag 22650 
 
9242 kshitij.so 22651 
class updateAsin_args:
22652 
  """
22653 
  Attributes:
22654 
   - item
22655 
  """
8616 vikram.rag 22656 
 
22657 
  thrift_spec = (
9242 kshitij.so 22658 
    None, # 0
22659 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22660 
  )
22661 
 
9242 kshitij.so 22662 
  def __init__(self, item=None,):
22663 
    self.item = item
22664 
 
8616 vikram.rag 22665 
  def read(self, iprot):
22666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22668 
      return
22669 
    iprot.readStructBegin()
22670 
    while True:
22671 
      (fname, ftype, fid) = iprot.readFieldBegin()
22672 
      if ftype == TType.STOP:
22673 
        break
9242 kshitij.so 22674 
      if fid == 1:
22675 
        if ftype == TType.MAP:
22676 
          self.item = {}
22677 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22678 
          for _i508 in xrange(_size504):
22679 
            _key509 = iprot.readI64();
22680 
            _val510 = Item()
22681 
            _val510.read(iprot)
22682 
            self.item[_key509] = _val510
22683 
          iprot.readMapEnd()
22684 
        else:
22685 
          iprot.skip(ftype)
8616 vikram.rag 22686 
      else:
22687 
        iprot.skip(ftype)
22688 
      iprot.readFieldEnd()
22689 
    iprot.readStructEnd()
22690 
 
22691 
  def write(self, oprot):
22692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22694 
      return
9242 kshitij.so 22695 
    oprot.writeStructBegin('updateAsin_args')
22696 
    if self.item is not None:
22697 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22698 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22699 
      for kiter511,viter512 in self.item.items():
22700 
        oprot.writeI64(kiter511)
22701 
        viter512.write(oprot)
22702 
      oprot.writeMapEnd()
22703 
      oprot.writeFieldEnd()
8616 vikram.rag 22704 
    oprot.writeFieldStop()
22705 
    oprot.writeStructEnd()
22706 
 
22707 
  def validate(self):
22708 
    return
22709 
 
22710 
 
22711 
  def __repr__(self):
22712 
    L = ['%s=%r' % (key, value)
22713 
      for key, value in self.__dict__.iteritems()]
22714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22715 
 
22716 
  def __eq__(self, other):
22717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22718 
 
22719 
  def __ne__(self, other):
22720 
    return not (self == other)
22721 
 
9242 kshitij.so 22722 
class updateAsin_result:
8616 vikram.rag 22723 
 
22724 
  thrift_spec = (
22725 
  )
22726 
 
22727 
  def read(self, iprot):
22728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22730 
      return
22731 
    iprot.readStructBegin()
22732 
    while True:
22733 
      (fname, ftype, fid) = iprot.readFieldBegin()
22734 
      if ftype == TType.STOP:
22735 
        break
22736 
      else:
22737 
        iprot.skip(ftype)
22738 
      iprot.readFieldEnd()
22739 
    iprot.readStructEnd()
22740 
 
22741 
  def write(self, oprot):
22742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22744 
      return
9242 kshitij.so 22745 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22746 
    oprot.writeFieldStop()
22747 
    oprot.writeStructEnd()
22748 
 
22749 
  def validate(self):
22750 
    return
22751 
 
22752 
 
22753 
  def __repr__(self):
22754 
    L = ['%s=%r' % (key, value)
22755 
      for key, value in self.__dict__.iteritems()]
22756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22757 
 
22758 
  def __eq__(self, other):
22759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22760 
 
22761 
  def __ne__(self, other):
22762 
    return not (self == other)
8619 kshitij.so 22763 
 
9242 kshitij.so 22764 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22765 
  """
22766 
  Attributes:
9242 kshitij.so 22767 
   - snapdealitem
8619 kshitij.so 22768 
  """
22769 
 
9242 kshitij.so 22770 
  thrift_spec = None
22771 
  def __init__(self, snapdealitem=None,):
22772 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22773 
 
22774 
  def read(self, iprot):
22775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22777 
      return
22778 
    iprot.readStructBegin()
22779 
    while True:
22780 
      (fname, ftype, fid) = iprot.readFieldBegin()
22781 
      if ftype == TType.STOP:
22782 
        break
9242 kshitij.so 22783 
      if fid == -1:
22784 
        if ftype == TType.STRUCT:
22785 
          self.snapdealitem = SnapdealItem()
22786 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22787 
        else:
22788 
          iprot.skip(ftype)
22789 
      else:
22790 
        iprot.skip(ftype)
22791 
      iprot.readFieldEnd()
22792 
    iprot.readStructEnd()
22793 
 
22794 
  def write(self, oprot):
22795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22797 
      return
9242 kshitij.so 22798 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22799 
    if self.snapdealitem is not None:
22800 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22801 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22802 
      oprot.writeFieldEnd()
22803 
    oprot.writeFieldStop()
22804 
    oprot.writeStructEnd()
22805 
 
22806 
  def validate(self):
22807 
    return
22808 
 
22809 
 
22810 
  def __repr__(self):
22811 
    L = ['%s=%r' % (key, value)
22812 
      for key, value in self.__dict__.iteritems()]
22813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22814 
 
22815 
  def __eq__(self, other):
22816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22817 
 
22818 
  def __ne__(self, other):
22819 
    return not (self == other)
22820 
 
9242 kshitij.so 22821 
class addOrUpdateSnapdealItem_result:
22822 
  """
22823 
  Attributes:
22824 
   - success
22825 
  """
8619 kshitij.so 22826 
 
22827 
  thrift_spec = (
9242 kshitij.so 22828 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22829 
  )
22830 
 
9242 kshitij.so 22831 
  def __init__(self, success=None,):
22832 
    self.success = success
22833 
 
8619 kshitij.so 22834 
  def read(self, iprot):
22835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22837 
      return
22838 
    iprot.readStructBegin()
22839 
    while True:
22840 
      (fname, ftype, fid) = iprot.readFieldBegin()
22841 
      if ftype == TType.STOP:
22842 
        break
9242 kshitij.so 22843 
      if fid == 0:
22844 
        if ftype == TType.BOOL:
22845 
          self.success = iprot.readBool();
22846 
        else:
22847 
          iprot.skip(ftype)
8619 kshitij.so 22848 
      else:
22849 
        iprot.skip(ftype)
22850 
      iprot.readFieldEnd()
22851 
    iprot.readStructEnd()
22852 
 
22853 
  def write(self, oprot):
22854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22856 
      return
9242 kshitij.so 22857 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22858 
    if self.success is not None:
22859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22860 
      oprot.writeBool(self.success)
22861 
      oprot.writeFieldEnd()
8619 kshitij.so 22862 
    oprot.writeFieldStop()
22863 
    oprot.writeStructEnd()
22864 
 
22865 
  def validate(self):
22866 
    return
22867 
 
22868 
 
22869 
  def __repr__(self):
22870 
    L = ['%s=%r' % (key, value)
22871 
      for key, value in self.__dict__.iteritems()]
22872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22873 
 
22874 
  def __eq__(self, other):
22875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22876 
 
22877 
  def __ne__(self, other):
22878 
    return not (self == other)
8739 vikram.rag 22879 
 
9242 kshitij.so 22880 
class getSnapdealItem_args:
8739 vikram.rag 22881 
  """
22882 
  Attributes:
9242 kshitij.so 22883 
   - item_id
8739 vikram.rag 22884 
  """
22885 
 
9242 kshitij.so 22886 
  thrift_spec = (
22887 
    None, # 0
22888 
    (1, TType.I64, 'item_id', None, None, ), # 1
22889 
  )
8739 vikram.rag 22890 
 
9242 kshitij.so 22891 
  def __init__(self, item_id=None,):
22892 
    self.item_id = item_id
22893 
 
8739 vikram.rag 22894 
  def read(self, iprot):
22895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22897 
      return
22898 
    iprot.readStructBegin()
22899 
    while True:
22900 
      (fname, ftype, fid) = iprot.readFieldBegin()
22901 
      if ftype == TType.STOP:
22902 
        break
9242 kshitij.so 22903 
      if fid == 1:
22904 
        if ftype == TType.I64:
22905 
          self.item_id = iprot.readI64();
8739 vikram.rag 22906 
        else:
22907 
          iprot.skip(ftype)
22908 
      else:
22909 
        iprot.skip(ftype)
22910 
      iprot.readFieldEnd()
22911 
    iprot.readStructEnd()
22912 
 
22913 
  def write(self, oprot):
22914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22916 
      return
9242 kshitij.so 22917 
    oprot.writeStructBegin('getSnapdealItem_args')
22918 
    if self.item_id is not None:
22919 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22920 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22921 
      oprot.writeFieldEnd()
22922 
    oprot.writeFieldStop()
22923 
    oprot.writeStructEnd()
22924 
 
22925 
  def validate(self):
22926 
    return
22927 
 
22928 
 
22929 
  def __repr__(self):
22930 
    L = ['%s=%r' % (key, value)
22931 
      for key, value in self.__dict__.iteritems()]
22932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22933 
 
22934 
  def __eq__(self, other):
22935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22936 
 
22937 
  def __ne__(self, other):
22938 
    return not (self == other)
22939 
 
9242 kshitij.so 22940 
class getSnapdealItem_result:
8739 vikram.rag 22941 
  """
22942 
  Attributes:
22943 
   - success
22944 
  """
22945 
 
22946 
  thrift_spec = (
9242 kshitij.so 22947 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 22948 
  )
22949 
 
22950 
  def __init__(self, success=None,):
22951 
    self.success = success
22952 
 
22953 
  def read(self, iprot):
22954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22956 
      return
22957 
    iprot.readStructBegin()
22958 
    while True:
22959 
      (fname, ftype, fid) = iprot.readFieldBegin()
22960 
      if ftype == TType.STOP:
22961 
        break
22962 
      if fid == 0:
9242 kshitij.so 22963 
        if ftype == TType.STRUCT:
22964 
          self.success = SnapdealItem()
22965 
          self.success.read(iprot)
8739 vikram.rag 22966 
        else:
22967 
          iprot.skip(ftype)
22968 
      else:
22969 
        iprot.skip(ftype)
22970 
      iprot.readFieldEnd()
22971 
    iprot.readStructEnd()
22972 
 
22973 
  def write(self, oprot):
22974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22976 
      return
9242 kshitij.so 22977 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 22978 
    if self.success is not None:
9242 kshitij.so 22979 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22980 
      self.success.write(oprot)
8739 vikram.rag 22981 
      oprot.writeFieldEnd()
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
22999 
 
9242 kshitij.so 23000 
class getSnapdealItemDetails_args:
8739 vikram.rag 23001 
  """
23002 
  Attributes:
23003 
   - item_id
23004 
  """
23005 
 
23006 
  thrift_spec = (
23007 
    None, # 0
23008 
    (1, TType.I64, 'item_id', None, None, ), # 1
23009 
  )
23010 
 
23011 
  def __init__(self, item_id=None,):
23012 
    self.item_id = item_id
23013 
 
23014 
  def read(self, iprot):
23015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23017 
      return
23018 
    iprot.readStructBegin()
23019 
    while True:
23020 
      (fname, ftype, fid) = iprot.readFieldBegin()
23021 
      if ftype == TType.STOP:
23022 
        break
23023 
      if fid == 1:
23024 
        if ftype == TType.I64:
23025 
          self.item_id = iprot.readI64();
23026 
        else:
23027 
          iprot.skip(ftype)
23028 
      else:
23029 
        iprot.skip(ftype)
23030 
      iprot.readFieldEnd()
23031 
    iprot.readStructEnd()
23032 
 
23033 
  def write(self, oprot):
23034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23036 
      return
9242 kshitij.so 23037 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23038 
    if self.item_id is not None:
23039 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23040 
      oprot.writeI64(self.item_id)
23041 
      oprot.writeFieldEnd()
23042 
    oprot.writeFieldStop()
23043 
    oprot.writeStructEnd()
23044 
 
23045 
  def validate(self):
23046 
    return
23047 
 
23048 
 
23049 
  def __repr__(self):
23050 
    L = ['%s=%r' % (key, value)
23051 
      for key, value in self.__dict__.iteritems()]
23052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23053 
 
23054 
  def __eq__(self, other):
23055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23056 
 
23057 
  def __ne__(self, other):
23058 
    return not (self == other)
23059 
 
9242 kshitij.so 23060 
class getSnapdealItemDetails_result:
8739 vikram.rag 23061 
  """
23062 
  Attributes:
23063 
   - success
23064 
  """
23065 
 
23066 
  thrift_spec = (
9242 kshitij.so 23067 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23068 
  )
23069 
 
23070 
  def __init__(self, success=None,):
23071 
    self.success = success
23072 
 
23073 
  def read(self, iprot):
23074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23076 
      return
23077 
    iprot.readStructBegin()
23078 
    while True:
23079 
      (fname, ftype, fid) = iprot.readFieldBegin()
23080 
      if ftype == TType.STOP:
23081 
        break
23082 
      if fid == 0:
23083 
        if ftype == TType.STRUCT:
9242 kshitij.so 23084 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23085 
          self.success.read(iprot)
23086 
        else:
23087 
          iprot.skip(ftype)
23088 
      else:
23089 
        iprot.skip(ftype)
23090 
      iprot.readFieldEnd()
23091 
    iprot.readStructEnd()
23092 
 
23093 
  def write(self, oprot):
23094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23096 
      return
9242 kshitij.so 23097 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23098 
    if self.success is not None:
23099 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23100 
      self.success.write(oprot)
23101 
      oprot.writeFieldEnd()
23102 
    oprot.writeFieldStop()
23103 
    oprot.writeStructEnd()
23104 
 
23105 
  def validate(self):
23106 
    return
23107 
 
23108 
 
23109 
  def __repr__(self):
23110 
    L = ['%s=%r' % (key, value)
23111 
      for key, value in self.__dict__.iteritems()]
23112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23113 
 
23114 
  def __eq__(self, other):
23115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23116 
 
23117 
  def __ne__(self, other):
23118 
    return not (self == other)
23119 
 
23120 
class getAllSnapdealItems_args:
23121 
 
23122 
  thrift_spec = (
23123 
  )
23124 
 
23125 
  def read(self, iprot):
23126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23128 
      return
23129 
    iprot.readStructBegin()
23130 
    while True:
23131 
      (fname, ftype, fid) = iprot.readFieldBegin()
23132 
      if ftype == TType.STOP:
23133 
        break
23134 
      else:
23135 
        iprot.skip(ftype)
23136 
      iprot.readFieldEnd()
23137 
    iprot.readStructEnd()
23138 
 
23139 
  def write(self, oprot):
23140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23142 
      return
23143 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23144 
    oprot.writeFieldStop()
23145 
    oprot.writeStructEnd()
23146 
 
23147 
  def validate(self):
23148 
    return
23149 
 
23150 
 
23151 
  def __repr__(self):
23152 
    L = ['%s=%r' % (key, value)
23153 
      for key, value in self.__dict__.iteritems()]
23154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23155 
 
23156 
  def __eq__(self, other):
23157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23158 
 
23159 
  def __ne__(self, other):
23160 
    return not (self == other)
23161 
 
23162 
class getAllSnapdealItems_result:
23163 
  """
23164 
  Attributes:
23165 
   - success
23166 
  """
23167 
 
23168 
  thrift_spec = (
9242 kshitij.so 23169 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23170 
  )
23171 
 
23172 
  def __init__(self, success=None,):
23173 
    self.success = success
23174 
 
23175 
  def read(self, iprot):
23176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23178 
      return
23179 
    iprot.readStructBegin()
23180 
    while True:
23181 
      (fname, ftype, fid) = iprot.readFieldBegin()
23182 
      if ftype == TType.STOP:
23183 
        break
23184 
      if fid == 0:
23185 
        if ftype == TType.LIST:
23186 
          self.success = []
9242 kshitij.so 23187 
          (_etype516, _size513) = iprot.readListBegin()
23188 
          for _i517 in xrange(_size513):
23189 
            _elem518 = SnapdealItemDetails()
23190 
            _elem518.read(iprot)
23191 
            self.success.append(_elem518)
23192 
          iprot.readListEnd()
23193 
        else:
23194 
          iprot.skip(ftype)
23195 
      else:
23196 
        iprot.skip(ftype)
23197 
      iprot.readFieldEnd()
23198 
    iprot.readStructEnd()
23199 
 
23200 
  def write(self, oprot):
23201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23203 
      return
23204 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23205 
    if self.success is not None:
23206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23208 
      for iter519 in self.success:
23209 
        iter519.write(oprot)
23210 
      oprot.writeListEnd()
23211 
      oprot.writeFieldEnd()
23212 
    oprot.writeFieldStop()
23213 
    oprot.writeStructEnd()
23214 
 
23215 
  def validate(self):
23216 
    return
23217 
 
23218 
 
23219 
  def __repr__(self):
23220 
    L = ['%s=%r' % (key, value)
23221 
      for key, value in self.__dict__.iteritems()]
23222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23223 
 
23224 
  def __eq__(self, other):
23225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23226 
 
23227 
  def __ne__(self, other):
23228 
    return not (self == other)
23229 
 
23230 
class getSnapdealItems_args:
23231 
  """
23232 
  Attributes:
23233 
   - offset
23234 
   - limit
23235 
  """
23236 
 
23237 
  thrift_spec = (
23238 
    None, # 0
23239 
    (1, TType.I64, 'offset', None, None, ), # 1
23240 
    (2, TType.I64, 'limit', None, None, ), # 2
23241 
  )
23242 
 
23243 
  def __init__(self, offset=None, limit=None,):
23244 
    self.offset = offset
23245 
    self.limit = limit
23246 
 
23247 
  def read(self, iprot):
23248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23250 
      return
23251 
    iprot.readStructBegin()
23252 
    while True:
23253 
      (fname, ftype, fid) = iprot.readFieldBegin()
23254 
      if ftype == TType.STOP:
23255 
        break
23256 
      if fid == 1:
23257 
        if ftype == TType.I64:
23258 
          self.offset = iprot.readI64();
23259 
        else:
23260 
          iprot.skip(ftype)
23261 
      elif fid == 2:
23262 
        if ftype == TType.I64:
23263 
          self.limit = iprot.readI64();
23264 
        else:
23265 
          iprot.skip(ftype)
23266 
      else:
23267 
        iprot.skip(ftype)
23268 
      iprot.readFieldEnd()
23269 
    iprot.readStructEnd()
23270 
 
23271 
  def write(self, oprot):
23272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23274 
      return
23275 
    oprot.writeStructBegin('getSnapdealItems_args')
23276 
    if self.offset is not None:
23277 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23278 
      oprot.writeI64(self.offset)
23279 
      oprot.writeFieldEnd()
23280 
    if self.limit is not None:
23281 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23282 
      oprot.writeI64(self.limit)
23283 
      oprot.writeFieldEnd()
23284 
    oprot.writeFieldStop()
23285 
    oprot.writeStructEnd()
23286 
 
23287 
  def validate(self):
23288 
    return
23289 
 
23290 
 
23291 
  def __repr__(self):
23292 
    L = ['%s=%r' % (key, value)
23293 
      for key, value in self.__dict__.iteritems()]
23294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23295 
 
23296 
  def __eq__(self, other):
23297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23298 
 
23299 
  def __ne__(self, other):
23300 
    return not (self == other)
23301 
 
23302 
class getSnapdealItems_result:
23303 
  """
23304 
  Attributes:
23305 
   - success
23306 
  """
23307 
 
23308 
  thrift_spec = (
23309 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23310 
  )
23311 
 
23312 
  def __init__(self, success=None,):
23313 
    self.success = success
23314 
 
23315 
  def read(self, iprot):
23316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23318 
      return
23319 
    iprot.readStructBegin()
23320 
    while True:
23321 
      (fname, ftype, fid) = iprot.readFieldBegin()
23322 
      if ftype == TType.STOP:
23323 
        break
23324 
      if fid == 0:
23325 
        if ftype == TType.LIST:
23326 
          self.success = []
9155 kshitij.so 23327 
          (_etype523, _size520) = iprot.readListBegin()
23328 
          for _i524 in xrange(_size520):
9242 kshitij.so 23329 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23330 
            _elem525.read(iprot)
23331 
            self.success.append(_elem525)
8739 vikram.rag 23332 
          iprot.readListEnd()
23333 
        else:
23334 
          iprot.skip(ftype)
23335 
      else:
23336 
        iprot.skip(ftype)
23337 
      iprot.readFieldEnd()
23338 
    iprot.readStructEnd()
23339 
 
23340 
  def write(self, oprot):
23341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23343 
      return
9242 kshitij.so 23344 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23345 
    if self.success is not None:
23346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23348 
      for iter526 in self.success:
23349 
        iter526.write(oprot)
8739 vikram.rag 23350 
      oprot.writeListEnd()
23351 
      oprot.writeFieldEnd()
23352 
    oprot.writeFieldStop()
23353 
    oprot.writeStructEnd()
23354 
 
23355 
  def validate(self):
23356 
    return
23357 
 
23358 
 
23359 
  def __repr__(self):
23360 
    L = ['%s=%r' % (key, value)
23361 
      for key, value in self.__dict__.iteritems()]
23362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23363 
 
23364 
  def __eq__(self, other):
23365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23366 
 
23367 
  def __ne__(self, other):
23368 
    return not (self == other)
9242 kshitij.so 23369 
 
23370 
class searchSnapdealItems_args:
23371 
  """
23372 
  Attributes:
23373 
   - searchTerm
23374 
   - offset
23375 
   - limit
23376 
  """
23377 
 
23378 
  thrift_spec = (
23379 
    None, # 0
23380 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23381 
    (2, TType.I64, 'offset', None, None, ), # 2
23382 
    (3, TType.I64, 'limit', None, None, ), # 3
23383 
  )
23384 
 
23385 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23386 
    self.searchTerm = searchTerm
23387 
    self.offset = offset
23388 
    self.limit = limit
23389 
 
23390 
  def read(self, iprot):
23391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23393 
      return
23394 
    iprot.readStructBegin()
23395 
    while True:
23396 
      (fname, ftype, fid) = iprot.readFieldBegin()
23397 
      if ftype == TType.STOP:
23398 
        break
23399 
      if fid == 1:
23400 
        if ftype == TType.LIST:
23401 
          self.searchTerm = []
23402 
          (_etype530, _size527) = iprot.readListBegin()
23403 
          for _i531 in xrange(_size527):
23404 
            _elem532 = iprot.readString();
23405 
            self.searchTerm.append(_elem532)
23406 
          iprot.readListEnd()
23407 
        else:
23408 
          iprot.skip(ftype)
23409 
      elif fid == 2:
23410 
        if ftype == TType.I64:
23411 
          self.offset = iprot.readI64();
23412 
        else:
23413 
          iprot.skip(ftype)
23414 
      elif fid == 3:
23415 
        if ftype == TType.I64:
23416 
          self.limit = iprot.readI64();
23417 
        else:
23418 
          iprot.skip(ftype)
23419 
      else:
23420 
        iprot.skip(ftype)
23421 
      iprot.readFieldEnd()
23422 
    iprot.readStructEnd()
23423 
 
23424 
  def write(self, oprot):
23425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23427 
      return
23428 
    oprot.writeStructBegin('searchSnapdealItems_args')
23429 
    if self.searchTerm is not None:
23430 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23431 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23432 
      for iter533 in self.searchTerm:
23433 
        oprot.writeString(iter533)
23434 
      oprot.writeListEnd()
23435 
      oprot.writeFieldEnd()
23436 
    if self.offset is not None:
23437 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23438 
      oprot.writeI64(self.offset)
23439 
      oprot.writeFieldEnd()
23440 
    if self.limit is not None:
23441 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23442 
      oprot.writeI64(self.limit)
23443 
      oprot.writeFieldEnd()
23444 
    oprot.writeFieldStop()
23445 
    oprot.writeStructEnd()
23446 
 
23447 
  def validate(self):
23448 
    return
23449 
 
23450 
 
23451 
  def __repr__(self):
23452 
    L = ['%s=%r' % (key, value)
23453 
      for key, value in self.__dict__.iteritems()]
23454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23455 
 
23456 
  def __eq__(self, other):
23457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23458 
 
23459 
  def __ne__(self, other):
23460 
    return not (self == other)
23461 
 
23462 
class searchSnapdealItems_result:
23463 
  """
23464 
  Attributes:
23465 
   - success
23466 
  """
23467 
 
23468 
  thrift_spec = (
23469 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23470 
  )
23471 
 
23472 
  def __init__(self, success=None,):
23473 
    self.success = success
23474 
 
23475 
  def read(self, iprot):
23476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23478 
      return
23479 
    iprot.readStructBegin()
23480 
    while True:
23481 
      (fname, ftype, fid) = iprot.readFieldBegin()
23482 
      if ftype == TType.STOP:
23483 
        break
23484 
      if fid == 0:
23485 
        if ftype == TType.LIST:
23486 
          self.success = []
23487 
          (_etype537, _size534) = iprot.readListBegin()
23488 
          for _i538 in xrange(_size534):
23489 
            _elem539 = SnapdealItemDetails()
23490 
            _elem539.read(iprot)
23491 
            self.success.append(_elem539)
23492 
          iprot.readListEnd()
23493 
        else:
23494 
          iprot.skip(ftype)
23495 
      else:
23496 
        iprot.skip(ftype)
23497 
      iprot.readFieldEnd()
23498 
    iprot.readStructEnd()
23499 
 
23500 
  def write(self, oprot):
23501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23503 
      return
23504 
    oprot.writeStructBegin('searchSnapdealItems_result')
23505 
    if self.success is not None:
23506 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23507 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23508 
      for iter540 in self.success:
23509 
        iter540.write(oprot)
23510 
      oprot.writeListEnd()
23511 
      oprot.writeFieldEnd()
23512 
    oprot.writeFieldStop()
23513 
    oprot.writeStructEnd()
23514 
 
23515 
  def validate(self):
23516 
    return
23517 
 
23518 
 
23519 
  def __repr__(self):
23520 
    L = ['%s=%r' % (key, value)
23521 
      for key, value in self.__dict__.iteritems()]
23522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23523 
 
23524 
  def __eq__(self, other):
23525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23526 
 
23527 
  def __ne__(self, other):
23528 
    return not (self == other)
23529 
 
23530 
class getCountForSnapdealItems_args:
23531 
 
23532 
  thrift_spec = (
23533 
  )
23534 
 
23535 
  def read(self, iprot):
23536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23538 
      return
23539 
    iprot.readStructBegin()
23540 
    while True:
23541 
      (fname, ftype, fid) = iprot.readFieldBegin()
23542 
      if ftype == TType.STOP:
23543 
        break
23544 
      else:
23545 
        iprot.skip(ftype)
23546 
      iprot.readFieldEnd()
23547 
    iprot.readStructEnd()
23548 
 
23549 
  def write(self, oprot):
23550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23552 
      return
23553 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23554 
    oprot.writeFieldStop()
23555 
    oprot.writeStructEnd()
23556 
 
23557 
  def validate(self):
23558 
    return
23559 
 
23560 
 
23561 
  def __repr__(self):
23562 
    L = ['%s=%r' % (key, value)
23563 
      for key, value in self.__dict__.iteritems()]
23564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23565 
 
23566 
  def __eq__(self, other):
23567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23568 
 
23569 
  def __ne__(self, other):
23570 
    return not (self == other)
23571 
 
23572 
class getCountForSnapdealItems_result:
23573 
  """
23574 
  Attributes:
23575 
   - success
23576 
  """
23577 
 
23578 
  thrift_spec = (
23579 
    (0, TType.I64, 'success', None, None, ), # 0
23580 
  )
23581 
 
23582 
  def __init__(self, success=None,):
23583 
    self.success = success
23584 
 
23585 
  def read(self, iprot):
23586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23588 
      return
23589 
    iprot.readStructBegin()
23590 
    while True:
23591 
      (fname, ftype, fid) = iprot.readFieldBegin()
23592 
      if ftype == TType.STOP:
23593 
        break
23594 
      if fid == 0:
23595 
        if ftype == TType.I64:
23596 
          self.success = iprot.readI64();
23597 
        else:
23598 
          iprot.skip(ftype)
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_result')
23609 
    if self.success is not None:
23610 
      oprot.writeFieldBegin('success', TType.I64, 0)
23611 
      oprot.writeI64(self.success)
23612 
      oprot.writeFieldEnd()
23613 
    oprot.writeFieldStop()
23614 
    oprot.writeStructEnd()
23615 
 
23616 
  def validate(self):
23617 
    return
23618 
 
23619 
 
23620 
  def __repr__(self):
23621 
    L = ['%s=%r' % (key, value)
23622 
      for key, value in self.__dict__.iteritems()]
23623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23624 
 
23625 
  def __eq__(self, other):
23626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23627 
 
23628 
  def __ne__(self, other):
23629 
    return not (self == other)
23630 
 
23631 
class getSnapdealSearchResultCount_args:
23632 
  """
23633 
  Attributes:
23634 
   - searchTerm
23635 
  """
23636 
 
23637 
  thrift_spec = (
23638 
    None, # 0
23639 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23640 
  )
23641 
 
23642 
  def __init__(self, searchTerm=None,):
23643 
    self.searchTerm = searchTerm
23644 
 
23645 
  def read(self, iprot):
23646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23648 
      return
23649 
    iprot.readStructBegin()
23650 
    while True:
23651 
      (fname, ftype, fid) = iprot.readFieldBegin()
23652 
      if ftype == TType.STOP:
23653 
        break
23654 
      if fid == 1:
23655 
        if ftype == TType.LIST:
23656 
          self.searchTerm = []
23657 
          (_etype544, _size541) = iprot.readListBegin()
23658 
          for _i545 in xrange(_size541):
23659 
            _elem546 = iprot.readString();
23660 
            self.searchTerm.append(_elem546)
23661 
          iprot.readListEnd()
23662 
        else:
23663 
          iprot.skip(ftype)
23664 
      else:
23665 
        iprot.skip(ftype)
23666 
      iprot.readFieldEnd()
23667 
    iprot.readStructEnd()
23668 
 
23669 
  def write(self, oprot):
23670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23672 
      return
23673 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23674 
    if self.searchTerm is not None:
23675 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23676 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23677 
      for iter547 in self.searchTerm:
23678 
        oprot.writeString(iter547)
23679 
      oprot.writeListEnd()
23680 
      oprot.writeFieldEnd()
23681 
    oprot.writeFieldStop()
23682 
    oprot.writeStructEnd()
23683 
 
23684 
  def validate(self):
23685 
    return
23686 
 
23687 
 
23688 
  def __repr__(self):
23689 
    L = ['%s=%r' % (key, value)
23690 
      for key, value in self.__dict__.iteritems()]
23691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23692 
 
23693 
  def __eq__(self, other):
23694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23695 
 
23696 
  def __ne__(self, other):
23697 
    return not (self == other)
23698 
 
23699 
class getSnapdealSearchResultCount_result:
23700 
  """
23701 
  Attributes:
23702 
   - success
23703 
  """
23704 
 
23705 
  thrift_spec = (
23706 
    (0, TType.I64, 'success', None, None, ), # 0
23707 
  )
23708 
 
23709 
  def __init__(self, success=None,):
23710 
    self.success = success
23711 
 
23712 
  def read(self, iprot):
23713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23715 
      return
23716 
    iprot.readStructBegin()
23717 
    while True:
23718 
      (fname, ftype, fid) = iprot.readFieldBegin()
23719 
      if ftype == TType.STOP:
23720 
        break
23721 
      if fid == 0:
23722 
        if ftype == TType.I64:
23723 
          self.success = iprot.readI64();
23724 
        else:
23725 
          iprot.skip(ftype)
23726 
      else:
23727 
        iprot.skip(ftype)
23728 
      iprot.readFieldEnd()
23729 
    iprot.readStructEnd()
23730 
 
23731 
  def write(self, oprot):
23732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23734 
      return
23735 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23736 
    if self.success is not None:
23737 
      oprot.writeFieldBegin('success', TType.I64, 0)
23738 
      oprot.writeI64(self.success)
23739 
      oprot.writeFieldEnd()
23740 
    oprot.writeFieldStop()
23741 
    oprot.writeStructEnd()
23742 
 
23743 
  def validate(self):
23744 
    return
23745 
 
23746 
 
23747 
  def __repr__(self):
23748 
    L = ['%s=%r' % (key, value)
23749 
      for key, value in self.__dict__.iteritems()]
23750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23751 
 
23752 
  def __eq__(self, other):
23753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23754 
 
23755 
  def __ne__(self, other):
23756 
    return not (self == other)
9299 kshitij.so 23757 
 
23758 
class getPrefferedInsurerForItem_args:
23759 
  """
23760 
  Attributes:
23761 
   - itemId
23762 
   - insurerType
23763 
  """
23764 
 
23765 
  thrift_spec = (
23766 
    None, # 0
23767 
    (1, TType.I64, 'itemId', None, None, ), # 1
23768 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23769 
  )
23770 
 
23771 
  def __init__(self, itemId=None, insurerType=None,):
23772 
    self.itemId = itemId
23773 
    self.insurerType = insurerType
23774 
 
23775 
  def read(self, iprot):
23776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23778 
      return
23779 
    iprot.readStructBegin()
23780 
    while True:
23781 
      (fname, ftype, fid) = iprot.readFieldBegin()
23782 
      if ftype == TType.STOP:
23783 
        break
23784 
      if fid == 1:
23785 
        if ftype == TType.I64:
23786 
          self.itemId = iprot.readI64();
23787 
        else:
23788 
          iprot.skip(ftype)
23789 
      elif fid == 2:
23790 
        if ftype == TType.I32:
23791 
          self.insurerType = iprot.readI32();
23792 
        else:
23793 
          iprot.skip(ftype)
23794 
      else:
23795 
        iprot.skip(ftype)
23796 
      iprot.readFieldEnd()
23797 
    iprot.readStructEnd()
23798 
 
23799 
  def write(self, oprot):
23800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23802 
      return
23803 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23804 
    if self.itemId is not None:
23805 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23806 
      oprot.writeI64(self.itemId)
23807 
      oprot.writeFieldEnd()
23808 
    if self.insurerType is not None:
23809 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23810 
      oprot.writeI32(self.insurerType)
23811 
      oprot.writeFieldEnd()
23812 
    oprot.writeFieldStop()
23813 
    oprot.writeStructEnd()
23814 
 
23815 
  def validate(self):
23816 
    return
23817 
 
23818 
 
23819 
  def __repr__(self):
23820 
    L = ['%s=%r' % (key, value)
23821 
      for key, value in self.__dict__.iteritems()]
23822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23823 
 
23824 
  def __eq__(self, other):
23825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23826 
 
23827 
  def __ne__(self, other):
23828 
    return not (self == other)
23829 
 
23830 
class getPrefferedInsurerForItem_result:
23831 
  """
23832 
  Attributes:
23833 
   - success
23834 
  """
23835 
 
23836 
  thrift_spec = (
23837 
    (0, TType.I64, 'success', None, None, ), # 0
23838 
  )
23839 
 
23840 
  def __init__(self, success=None,):
23841 
    self.success = success
23842 
 
23843 
  def read(self, iprot):
23844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23846 
      return
23847 
    iprot.readStructBegin()
23848 
    while True:
23849 
      (fname, ftype, fid) = iprot.readFieldBegin()
23850 
      if ftype == TType.STOP:
23851 
        break
23852 
      if fid == 0:
23853 
        if ftype == TType.I64:
23854 
          self.success = iprot.readI64();
23855 
        else:
23856 
          iprot.skip(ftype)
23857 
      else:
23858 
        iprot.skip(ftype)
23859 
      iprot.readFieldEnd()
23860 
    iprot.readStructEnd()
23861 
 
23862 
  def write(self, oprot):
23863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23865 
      return
23866 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
23867 
    if self.success is not None:
23868 
      oprot.writeFieldBegin('success', TType.I64, 0)
23869 
      oprot.writeI64(self.success)
23870 
      oprot.writeFieldEnd()
23871 
    oprot.writeFieldStop()
23872 
    oprot.writeStructEnd()
23873 
 
23874 
  def validate(self):
23875 
    return
23876 
 
23877 
 
23878 
  def __repr__(self):
23879 
    L = ['%s=%r' % (key, value)
23880 
      for key, value in self.__dict__.iteritems()]
23881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23882 
 
23883 
  def __eq__(self, other):
23884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23885 
 
23886 
  def __ne__(self, other):
23887 
    return not (self == other)
9456 vikram.rag 23888 
 
23889 
class getSnapdealItembySkuAtSnapdeal_args:
23890 
  """
23891 
  Attributes:
23892 
   - skuAtSnapdeal
23893 
  """
23894 
 
23895 
  thrift_spec = None
23896 
  def __init__(self, skuAtSnapdeal=None,):
23897 
    self.skuAtSnapdeal = skuAtSnapdeal
23898 
 
23899 
  def read(self, iprot):
23900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23902 
      return
23903 
    iprot.readStructBegin()
23904 
    while True:
23905 
      (fname, ftype, fid) = iprot.readFieldBegin()
23906 
      if ftype == TType.STOP:
23907 
        break
23908 
      if fid == -1:
23909 
        if ftype == TType.STRING:
23910 
          self.skuAtSnapdeal = iprot.readString();
23911 
        else:
23912 
          iprot.skip(ftype)
23913 
      else:
23914 
        iprot.skip(ftype)
23915 
      iprot.readFieldEnd()
23916 
    iprot.readStructEnd()
23917 
 
23918 
  def write(self, oprot):
23919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23921 
      return
23922 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
23923 
    if self.skuAtSnapdeal is not None:
23924 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
23925 
      oprot.writeString(self.skuAtSnapdeal)
23926 
      oprot.writeFieldEnd()
23927 
    oprot.writeFieldStop()
23928 
    oprot.writeStructEnd()
23929 
 
23930 
  def validate(self):
23931 
    return
23932 
 
23933 
 
23934 
  def __repr__(self):
23935 
    L = ['%s=%r' % (key, value)
23936 
      for key, value in self.__dict__.iteritems()]
23937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23938 
 
23939 
  def __eq__(self, other):
23940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23941 
 
23942 
  def __ne__(self, other):
23943 
    return not (self == other)
23944 
 
23945 
class getSnapdealItembySkuAtSnapdeal_result:
23946 
  """
23947 
  Attributes:
23948 
   - success
23949 
  """
23950 
 
23951 
  thrift_spec = (
23952 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
23953 
  )
23954 
 
23955 
  def __init__(self, success=None,):
23956 
    self.success = success
23957 
 
23958 
  def read(self, iprot):
23959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23961 
      return
23962 
    iprot.readStructBegin()
23963 
    while True:
23964 
      (fname, ftype, fid) = iprot.readFieldBegin()
23965 
      if ftype == TType.STOP:
23966 
        break
23967 
      if fid == 0:
23968 
        if ftype == TType.STRUCT:
23969 
          self.success = SnapdealItem()
23970 
          self.success.read(iprot)
23971 
        else:
23972 
          iprot.skip(ftype)
23973 
      else:
23974 
        iprot.skip(ftype)
23975 
      iprot.readFieldEnd()
23976 
    iprot.readStructEnd()
23977 
 
23978 
  def write(self, oprot):
23979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23981 
      return
23982 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
23983 
    if self.success is not None:
23984 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23985 
      self.success.write(oprot)
23986 
      oprot.writeFieldEnd()
23987 
    oprot.writeFieldStop()
23988 
    oprot.writeStructEnd()
23989 
 
23990 
  def validate(self):
23991 
    return
23992 
 
23993 
 
23994 
  def __repr__(self):
23995 
    L = ['%s=%r' % (key, value)
23996 
      for key, value in self.__dict__.iteritems()]
23997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23998 
 
23999 
  def __eq__(self, other):
24000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24001 
 
24002 
  def __ne__(self, other):
24003 
    return not (self == other)
9621 manish.sha 24004 
 
24005 
class getProductFeedSubmit_args:
24006 
  """
24007 
  Attributes:
24008 
   - catalogItemId
24009 
  """
24010 
 
24011 
  thrift_spec = (
24012 
    None, # 0
24013 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24014 
  )
24015 
 
24016 
  def __init__(self, catalogItemId=None,):
24017 
    self.catalogItemId = catalogItemId
24018 
 
24019 
  def read(self, iprot):
24020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24022 
      return
24023 
    iprot.readStructBegin()
24024 
    while True:
24025 
      (fname, ftype, fid) = iprot.readFieldBegin()
24026 
      if ftype == TType.STOP:
24027 
        break
24028 
      if fid == 1:
24029 
        if ftype == TType.I64:
24030 
          self.catalogItemId = iprot.readI64();
24031 
        else:
24032 
          iprot.skip(ftype)
24033 
      else:
24034 
        iprot.skip(ftype)
24035 
      iprot.readFieldEnd()
24036 
    iprot.readStructEnd()
24037 
 
24038 
  def write(self, oprot):
24039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24041 
      return
24042 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24043 
    if self.catalogItemId is not None:
24044 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24045 
      oprot.writeI64(self.catalogItemId)
24046 
      oprot.writeFieldEnd()
24047 
    oprot.writeFieldStop()
24048 
    oprot.writeStructEnd()
24049 
 
24050 
  def validate(self):
24051 
    return
24052 
 
24053 
 
24054 
  def __repr__(self):
24055 
    L = ['%s=%r' % (key, value)
24056 
      for key, value in self.__dict__.iteritems()]
24057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24058 
 
24059 
  def __eq__(self, other):
24060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24061 
 
24062 
  def __ne__(self, other):
24063 
    return not (self == other)
24064 
 
24065 
class getProductFeedSubmit_result:
24066 
  """
24067 
  Attributes:
24068 
   - success
24069 
   - cex
24070 
  """
24071 
 
24072 
  thrift_spec = (
24073 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24074 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24075 
  )
24076 
 
24077 
  def __init__(self, success=None, cex=None,):
24078 
    self.success = success
24079 
    self.cex = cex
24080 
 
24081 
  def read(self, iprot):
24082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24084 
      return
24085 
    iprot.readStructBegin()
24086 
    while True:
24087 
      (fname, ftype, fid) = iprot.readFieldBegin()
24088 
      if ftype == TType.STOP:
24089 
        break
24090 
      if fid == 0:
24091 
        if ftype == TType.STRUCT:
24092 
          self.success = ProductFeedSubmit()
24093 
          self.success.read(iprot)
24094 
        else:
24095 
          iprot.skip(ftype)
24096 
      elif fid == 1:
24097 
        if ftype == TType.STRUCT:
24098 
          self.cex = CatalogServiceException()
24099 
          self.cex.read(iprot)
24100 
        else:
24101 
          iprot.skip(ftype)
24102 
      else:
24103 
        iprot.skip(ftype)
24104 
      iprot.readFieldEnd()
24105 
    iprot.readStructEnd()
24106 
 
24107 
  def write(self, oprot):
24108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24110 
      return
24111 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24112 
    if self.success is not None:
24113 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24114 
      self.success.write(oprot)
24115 
      oprot.writeFieldEnd()
24116 
    if self.cex is not None:
24117 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24118 
      self.cex.write(oprot)
24119 
      oprot.writeFieldEnd()
24120 
    oprot.writeFieldStop()
24121 
    oprot.writeStructEnd()
24122 
 
24123 
  def validate(self):
24124 
    return
24125 
 
24126 
 
24127 
  def __repr__(self):
24128 
    L = ['%s=%r' % (key, value)
24129 
      for key, value in self.__dict__.iteritems()]
24130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24131 
 
24132 
  def __eq__(self, other):
24133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24134 
 
24135 
  def __ne__(self, other):
24136 
    return not (self == other)
24137 
 
24138 
class addProductFeedSubmit_args:
24139 
  """
24140 
  Attributes:
24141 
   - productFeedSubmit
24142 
  """
24143 
 
24144 
  thrift_spec = (
24145 
    None, # 0
24146 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24147 
  )
24148 
 
24149 
  def __init__(self, productFeedSubmit=None,):
24150 
    self.productFeedSubmit = productFeedSubmit
24151 
 
24152 
  def read(self, iprot):
24153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24155 
      return
24156 
    iprot.readStructBegin()
24157 
    while True:
24158 
      (fname, ftype, fid) = iprot.readFieldBegin()
24159 
      if ftype == TType.STOP:
24160 
        break
24161 
      if fid == 1:
24162 
        if ftype == TType.STRUCT:
24163 
          self.productFeedSubmit = ProductFeedSubmit()
24164 
          self.productFeedSubmit.read(iprot)
24165 
        else:
24166 
          iprot.skip(ftype)
24167 
      else:
24168 
        iprot.skip(ftype)
24169 
      iprot.readFieldEnd()
24170 
    iprot.readStructEnd()
24171 
 
24172 
  def write(self, oprot):
24173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24175 
      return
24176 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24177 
    if self.productFeedSubmit is not None:
24178 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24179 
      self.productFeedSubmit.write(oprot)
24180 
      oprot.writeFieldEnd()
24181 
    oprot.writeFieldStop()
24182 
    oprot.writeStructEnd()
24183 
 
24184 
  def validate(self):
24185 
    return
24186 
 
24187 
 
24188 
  def __repr__(self):
24189 
    L = ['%s=%r' % (key, value)
24190 
      for key, value in self.__dict__.iteritems()]
24191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24192 
 
24193 
  def __eq__(self, other):
24194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24195 
 
24196 
  def __ne__(self, other):
24197 
    return not (self == other)
24198 
 
24199 
class addProductFeedSubmit_result:
24200 
  """
24201 
  Attributes:
24202 
   - success
24203 
   - cex
24204 
  """
24205 
 
24206 
  thrift_spec = (
24207 
    (0, TType.BOOL, 'success', None, None, ), # 0
24208 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24209 
  )
24210 
 
24211 
  def __init__(self, success=None, cex=None,):
24212 
    self.success = success
24213 
    self.cex = cex
24214 
 
24215 
  def read(self, iprot):
24216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24218 
      return
24219 
    iprot.readStructBegin()
24220 
    while True:
24221 
      (fname, ftype, fid) = iprot.readFieldBegin()
24222 
      if ftype == TType.STOP:
24223 
        break
24224 
      if fid == 0:
24225 
        if ftype == TType.BOOL:
24226 
          self.success = iprot.readBool();
24227 
        else:
24228 
          iprot.skip(ftype)
24229 
      elif fid == 1:
24230 
        if ftype == TType.STRUCT:
24231 
          self.cex = CatalogServiceException()
24232 
          self.cex.read(iprot)
24233 
        else:
24234 
          iprot.skip(ftype)
24235 
      else:
24236 
        iprot.skip(ftype)
24237 
      iprot.readFieldEnd()
24238 
    iprot.readStructEnd()
24239 
 
24240 
  def write(self, oprot):
24241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24243 
      return
24244 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24245 
    if self.success is not None:
24246 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24247 
      oprot.writeBool(self.success)
24248 
      oprot.writeFieldEnd()
24249 
    if self.cex is not None:
24250 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24251 
      self.cex.write(oprot)
24252 
      oprot.writeFieldEnd()
24253 
    oprot.writeFieldStop()
24254 
    oprot.writeStructEnd()
24255 
 
24256 
  def validate(self):
24257 
    return
24258 
 
24259 
 
24260 
  def __repr__(self):
24261 
    L = ['%s=%r' % (key, value)
24262 
      for key, value in self.__dict__.iteritems()]
24263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24264 
 
24265 
  def __eq__(self, other):
24266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24267 
 
24268 
  def __ne__(self, other):
24269 
    return not (self == other)
24270 
 
24271 
class updateProductFeedSubmit_args:
24272 
  """
24273 
  Attributes:
24274 
   - productFeedSubmit
24275 
  """
24276 
 
24277 
  thrift_spec = (
24278 
    None, # 0
24279 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24280 
  )
24281 
 
24282 
  def __init__(self, productFeedSubmit=None,):
24283 
    self.productFeedSubmit = productFeedSubmit
24284 
 
24285 
  def read(self, iprot):
24286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24288 
      return
24289 
    iprot.readStructBegin()
24290 
    while True:
24291 
      (fname, ftype, fid) = iprot.readFieldBegin()
24292 
      if ftype == TType.STOP:
24293 
        break
24294 
      if fid == 1:
24295 
        if ftype == TType.STRUCT:
24296 
          self.productFeedSubmit = ProductFeedSubmit()
24297 
          self.productFeedSubmit.read(iprot)
24298 
        else:
24299 
          iprot.skip(ftype)
24300 
      else:
24301 
        iprot.skip(ftype)
24302 
      iprot.readFieldEnd()
24303 
    iprot.readStructEnd()
24304 
 
24305 
  def write(self, oprot):
24306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24308 
      return
24309 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24310 
    if self.productFeedSubmit is not None:
24311 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24312 
      self.productFeedSubmit.write(oprot)
24313 
      oprot.writeFieldEnd()
24314 
    oprot.writeFieldStop()
24315 
    oprot.writeStructEnd()
24316 
 
24317 
  def validate(self):
24318 
    return
24319 
 
24320 
 
24321 
  def __repr__(self):
24322 
    L = ['%s=%r' % (key, value)
24323 
      for key, value in self.__dict__.iteritems()]
24324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24325 
 
24326 
  def __eq__(self, other):
24327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24328 
 
24329 
  def __ne__(self, other):
24330 
    return not (self == other)
24331 
 
24332 
class updateProductFeedSubmit_result:
24333 
  """
24334 
  Attributes:
24335 
   - success
24336 
   - cex
24337 
  """
24338 
 
24339 
  thrift_spec = (
24340 
    (0, TType.BOOL, 'success', None, None, ), # 0
24341 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24342 
  )
24343 
 
24344 
  def __init__(self, success=None, cex=None,):
24345 
    self.success = success
24346 
    self.cex = cex
24347 
 
24348 
  def read(self, iprot):
24349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24351 
      return
24352 
    iprot.readStructBegin()
24353 
    while True:
24354 
      (fname, ftype, fid) = iprot.readFieldBegin()
24355 
      if ftype == TType.STOP:
24356 
        break
24357 
      if fid == 0:
24358 
        if ftype == TType.BOOL:
24359 
          self.success = iprot.readBool();
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      elif fid == 1:
24363 
        if ftype == TType.STRUCT:
24364 
          self.cex = CatalogServiceException()
24365 
          self.cex.read(iprot)
24366 
        else:
24367 
          iprot.skip(ftype)
24368 
      else:
24369 
        iprot.skip(ftype)
24370 
      iprot.readFieldEnd()
24371 
    iprot.readStructEnd()
24372 
 
24373 
  def write(self, oprot):
24374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24376 
      return
24377 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24378 
    if self.success is not None:
24379 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24380 
      oprot.writeBool(self.success)
24381 
      oprot.writeFieldEnd()
24382 
    if self.cex is not None:
24383 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24384 
      self.cex.write(oprot)
24385 
      oprot.writeFieldEnd()
24386 
    oprot.writeFieldStop()
24387 
    oprot.writeStructEnd()
24388 
 
24389 
  def validate(self):
24390 
    return
24391 
 
24392 
 
24393 
  def __repr__(self):
24394 
    L = ['%s=%r' % (key, value)
24395 
      for key, value in self.__dict__.iteritems()]
24396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24397 
 
24398 
  def __eq__(self, other):
24399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24400 
 
24401 
  def __ne__(self, other):
24402 
    return not (self == other)
24403 
 
24404 
class deleteProductFeedSubmit_args:
24405 
  """
24406 
  Attributes:
24407 
   - catalogItemId
24408 
  """
24409 
 
24410 
  thrift_spec = (
24411 
    None, # 0
24412 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24413 
  )
24414 
 
24415 
  def __init__(self, catalogItemId=None,):
24416 
    self.catalogItemId = catalogItemId
24417 
 
24418 
  def read(self, iprot):
24419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24421 
      return
24422 
    iprot.readStructBegin()
24423 
    while True:
24424 
      (fname, ftype, fid) = iprot.readFieldBegin()
24425 
      if ftype == TType.STOP:
24426 
        break
24427 
      if fid == 1:
24428 
        if ftype == TType.I64:
24429 
          self.catalogItemId = iprot.readI64();
24430 
        else:
24431 
          iprot.skip(ftype)
24432 
      else:
24433 
        iprot.skip(ftype)
24434 
      iprot.readFieldEnd()
24435 
    iprot.readStructEnd()
24436 
 
24437 
  def write(self, oprot):
24438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24440 
      return
24441 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24442 
    if self.catalogItemId is not None:
24443 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24444 
      oprot.writeI64(self.catalogItemId)
24445 
      oprot.writeFieldEnd()
24446 
    oprot.writeFieldStop()
24447 
    oprot.writeStructEnd()
24448 
 
24449 
  def validate(self):
24450 
    return
24451 
 
24452 
 
24453 
  def __repr__(self):
24454 
    L = ['%s=%r' % (key, value)
24455 
      for key, value in self.__dict__.iteritems()]
24456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24457 
 
24458 
  def __eq__(self, other):
24459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24460 
 
24461 
  def __ne__(self, other):
24462 
    return not (self == other)
24463 
 
24464 
class deleteProductFeedSubmit_result:
24465 
  """
24466 
  Attributes:
24467 
   - success
24468 
   - cex
24469 
  """
24470 
 
24471 
  thrift_spec = (
24472 
    (0, TType.BOOL, 'success', None, None, ), # 0
24473 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24474 
  )
24475 
 
24476 
  def __init__(self, success=None, cex=None,):
24477 
    self.success = success
24478 
    self.cex = cex
24479 
 
24480 
  def read(self, iprot):
24481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24483 
      return
24484 
    iprot.readStructBegin()
24485 
    while True:
24486 
      (fname, ftype, fid) = iprot.readFieldBegin()
24487 
      if ftype == TType.STOP:
24488 
        break
24489 
      if fid == 0:
24490 
        if ftype == TType.BOOL:
24491 
          self.success = iprot.readBool();
24492 
        else:
24493 
          iprot.skip(ftype)
24494 
      elif fid == 1:
24495 
        if ftype == TType.STRUCT:
24496 
          self.cex = CatalogServiceException()
24497 
          self.cex.read(iprot)
24498 
        else:
24499 
          iprot.skip(ftype)
24500 
      else:
24501 
        iprot.skip(ftype)
24502 
      iprot.readFieldEnd()
24503 
    iprot.readStructEnd()
24504 
 
24505 
  def write(self, oprot):
24506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24508 
      return
24509 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24510 
    if self.success is not None:
24511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24512 
      oprot.writeBool(self.success)
24513 
      oprot.writeFieldEnd()
24514 
    if self.cex is not None:
24515 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24516 
      self.cex.write(oprot)
24517 
      oprot.writeFieldEnd()
24518 
    oprot.writeFieldStop()
24519 
    oprot.writeStructEnd()
24520 
 
24521 
  def validate(self):
24522 
    return
24523 
 
24524 
 
24525 
  def __repr__(self):
24526 
    L = ['%s=%r' % (key, value)
24527 
      for key, value in self.__dict__.iteritems()]
24528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24529 
 
24530 
  def __eq__(self, other):
24531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24532 
 
24533 
  def __ne__(self, other):
24534 
    return not (self == other)
24535 
 
24536 
class getAllProductFeedSubmit_args:
24537 
 
24538 
  thrift_spec = (
24539 
  )
24540 
 
24541 
  def read(self, iprot):
24542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24544 
      return
24545 
    iprot.readStructBegin()
24546 
    while True:
24547 
      (fname, ftype, fid) = iprot.readFieldBegin()
24548 
      if ftype == TType.STOP:
24549 
        break
24550 
      else:
24551 
        iprot.skip(ftype)
24552 
      iprot.readFieldEnd()
24553 
    iprot.readStructEnd()
24554 
 
24555 
  def write(self, oprot):
24556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24558 
      return
24559 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24560 
    oprot.writeFieldStop()
24561 
    oprot.writeStructEnd()
24562 
 
24563 
  def validate(self):
24564 
    return
24565 
 
24566 
 
24567 
  def __repr__(self):
24568 
    L = ['%s=%r' % (key, value)
24569 
      for key, value in self.__dict__.iteritems()]
24570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24571 
 
24572 
  def __eq__(self, other):
24573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24574 
 
24575 
  def __ne__(self, other):
24576 
    return not (self == other)
24577 
 
24578 
class getAllProductFeedSubmit_result:
24579 
  """
24580 
  Attributes:
24581 
   - success
24582 
   - cex
24583 
  """
24584 
 
24585 
  thrift_spec = (
24586 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24587 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24588 
  )
24589 
 
24590 
  def __init__(self, success=None, cex=None,):
24591 
    self.success = success
24592 
    self.cex = cex
24593 
 
24594 
  def read(self, iprot):
24595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24597 
      return
24598 
    iprot.readStructBegin()
24599 
    while True:
24600 
      (fname, ftype, fid) = iprot.readFieldBegin()
24601 
      if ftype == TType.STOP:
24602 
        break
24603 
      if fid == 0:
24604 
        if ftype == TType.LIST:
24605 
          self.success = []
24606 
          (_etype551, _size548) = iprot.readListBegin()
24607 
          for _i552 in xrange(_size548):
24608 
            _elem553 = ProductFeedSubmit()
24609 
            _elem553.read(iprot)
24610 
            self.success.append(_elem553)
24611 
          iprot.readListEnd()
24612 
        else:
24613 
          iprot.skip(ftype)
24614 
      elif fid == 1:
24615 
        if ftype == TType.STRUCT:
24616 
          self.cex = CatalogServiceException()
24617 
          self.cex.read(iprot)
24618 
        else:
24619 
          iprot.skip(ftype)
24620 
      else:
24621 
        iprot.skip(ftype)
24622 
      iprot.readFieldEnd()
24623 
    iprot.readStructEnd()
24624 
 
24625 
  def write(self, oprot):
24626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24628 
      return
24629 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24630 
    if self.success is not None:
24631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24633 
      for iter554 in self.success:
24634 
        iter554.write(oprot)
24635 
      oprot.writeListEnd()
24636 
      oprot.writeFieldEnd()
24637 
    if self.cex is not None:
24638 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24639 
      self.cex.write(oprot)
24640 
      oprot.writeFieldEnd()
24641 
    oprot.writeFieldStop()
24642 
    oprot.writeStructEnd()
24643 
 
24644 
  def validate(self):
24645 
    return
24646 
 
24647 
 
24648 
  def __repr__(self):
24649 
    L = ['%s=%r' % (key, value)
24650 
      for key, value in self.__dict__.iteritems()]
24651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24652 
 
24653 
  def __eq__(self, other):
24654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24655 
 
24656 
  def __ne__(self, other):
24657 
    return not (self == other)
9724 kshitij.so 24658 
 
24659 
class getMarketplacedetailsForItem_args:
24660 
  """
24661 
  Attributes:
24662 
   - itemId
24663 
   - sourceId
24664 
  """
24665 
 
24666 
  thrift_spec = (
24667 
    None, # 0
24668 
    (1, TType.I64, 'itemId', None, None, ), # 1
24669 
    (2, TType.I64, 'sourceId', None, None, ), # 2
24670 
  )
24671 
 
24672 
  def __init__(self, itemId=None, sourceId=None,):
24673 
    self.itemId = itemId
24674 
    self.sourceId = sourceId
24675 
 
24676 
  def read(self, iprot):
24677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24679 
      return
24680 
    iprot.readStructBegin()
24681 
    while True:
24682 
      (fname, ftype, fid) = iprot.readFieldBegin()
24683 
      if ftype == TType.STOP:
24684 
        break
24685 
      if fid == 1:
24686 
        if ftype == TType.I64:
24687 
          self.itemId = iprot.readI64();
24688 
        else:
24689 
          iprot.skip(ftype)
24690 
      elif fid == 2:
24691 
        if ftype == TType.I64:
24692 
          self.sourceId = iprot.readI64();
24693 
        else:
24694 
          iprot.skip(ftype)
24695 
      else:
24696 
        iprot.skip(ftype)
24697 
      iprot.readFieldEnd()
24698 
    iprot.readStructEnd()
24699 
 
24700 
  def write(self, oprot):
24701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24703 
      return
24704 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
24705 
    if self.itemId is not None:
24706 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24707 
      oprot.writeI64(self.itemId)
24708 
      oprot.writeFieldEnd()
24709 
    if self.sourceId is not None:
24710 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
24711 
      oprot.writeI64(self.sourceId)
24712 
      oprot.writeFieldEnd()
24713 
    oprot.writeFieldStop()
24714 
    oprot.writeStructEnd()
24715 
 
24716 
  def validate(self):
24717 
    return
24718 
 
24719 
 
24720 
  def __repr__(self):
24721 
    L = ['%s=%r' % (key, value)
24722 
      for key, value in self.__dict__.iteritems()]
24723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24724 
 
24725 
  def __eq__(self, other):
24726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24727 
 
24728 
  def __ne__(self, other):
24729 
    return not (self == other)
24730 
 
24731 
class getMarketplacedetailsForItem_result:
24732 
  """
24733 
  Attributes:
24734 
   - success
24735 
  """
24736 
 
24737 
  thrift_spec = (
24738 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
24739 
  )
24740 
 
24741 
  def __init__(self, success=None,):
24742 
    self.success = success
24743 
 
24744 
  def read(self, iprot):
24745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24747 
      return
24748 
    iprot.readStructBegin()
24749 
    while True:
24750 
      (fname, ftype, fid) = iprot.readFieldBegin()
24751 
      if ftype == TType.STOP:
24752 
        break
24753 
      if fid == 0:
24754 
        if ftype == TType.STRUCT:
24755 
          self.success = MarketplaceItems()
24756 
          self.success.read(iprot)
24757 
        else:
24758 
          iprot.skip(ftype)
24759 
      else:
24760 
        iprot.skip(ftype)
24761 
      iprot.readFieldEnd()
24762 
    iprot.readStructEnd()
24763 
 
24764 
  def write(self, oprot):
24765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24767 
      return
24768 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
24769 
    if self.success is not None:
24770 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24771 
      self.success.write(oprot)
24772 
      oprot.writeFieldEnd()
24773 
    oprot.writeFieldStop()
24774 
    oprot.writeStructEnd()
24775 
 
24776 
  def validate(self):
24777 
    return
24778 
 
24779 
 
24780 
  def __repr__(self):
24781 
    L = ['%s=%r' % (key, value)
24782 
      for key, value in self.__dict__.iteritems()]
24783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24784 
 
24785 
  def __eq__(self, other):
24786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24787 
 
24788 
  def __ne__(self, other):
24789 
    return not (self == other)
24790 
 
24791 
class updateMarketplaceAttributesForItem_args:
24792 
  """
24793 
  Attributes:
24794 
   - marketPlaceItem
24795 
  """
24796 
 
24797 
  thrift_spec = (
24798 
    None, # 0
24799 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
24800 
  )
24801 
 
24802 
  def __init__(self, marketPlaceItem=None,):
24803 
    self.marketPlaceItem = marketPlaceItem
24804 
 
24805 
  def read(self, iprot):
24806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24808 
      return
24809 
    iprot.readStructBegin()
24810 
    while True:
24811 
      (fname, ftype, fid) = iprot.readFieldBegin()
24812 
      if ftype == TType.STOP:
24813 
        break
24814 
      if fid == 1:
24815 
        if ftype == TType.STRUCT:
24816 
          self.marketPlaceItem = MarketplaceItems()
24817 
          self.marketPlaceItem.read(iprot)
24818 
        else:
24819 
          iprot.skip(ftype)
24820 
      else:
24821 
        iprot.skip(ftype)
24822 
      iprot.readFieldEnd()
24823 
    iprot.readStructEnd()
24824 
 
24825 
  def write(self, oprot):
24826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24828 
      return
24829 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
24830 
    if self.marketPlaceItem is not None:
24831 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
24832 
      self.marketPlaceItem.write(oprot)
24833 
      oprot.writeFieldEnd()
24834 
    oprot.writeFieldStop()
24835 
    oprot.writeStructEnd()
24836 
 
24837 
  def validate(self):
24838 
    return
24839 
 
24840 
 
24841 
  def __repr__(self):
24842 
    L = ['%s=%r' % (key, value)
24843 
      for key, value in self.__dict__.iteritems()]
24844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24845 
 
24846 
  def __eq__(self, other):
24847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24848 
 
24849 
  def __ne__(self, other):
24850 
    return not (self == other)
24851 
 
24852 
class updateMarketplaceAttributesForItem_result:
24853 
  """
24854 
  Attributes:
24855 
   - success
24856 
  """
24857 
 
24858 
  thrift_spec = (
24859 
    (0, TType.BOOL, 'success', None, None, ), # 0
24860 
  )
24861 
 
24862 
  def __init__(self, success=None,):
24863 
    self.success = success
24864 
 
24865 
  def read(self, iprot):
24866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24868 
      return
24869 
    iprot.readStructBegin()
24870 
    while True:
24871 
      (fname, ftype, fid) = iprot.readFieldBegin()
24872 
      if ftype == TType.STOP:
24873 
        break
24874 
      if fid == 0:
24875 
        if ftype == TType.BOOL:
24876 
          self.success = iprot.readBool();
24877 
        else:
24878 
          iprot.skip(ftype)
24879 
      else:
24880 
        iprot.skip(ftype)
24881 
      iprot.readFieldEnd()
24882 
    iprot.readStructEnd()
24883 
 
24884 
  def write(self, oprot):
24885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24887 
      return
24888 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
24889 
    if self.success is not None:
24890 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24891 
      oprot.writeBool(self.success)
24892 
      oprot.writeFieldEnd()
24893 
    oprot.writeFieldStop()
24894 
    oprot.writeStructEnd()
24895 
 
24896 
  def validate(self):
24897 
    return
24898 
 
24899 
 
24900 
  def __repr__(self):
24901 
    L = ['%s=%r' % (key, value)
24902 
      for key, value in self.__dict__.iteritems()]
24903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24904 
 
24905 
  def __eq__(self, other):
24906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24907 
 
24908 
  def __ne__(self, other):
24909 
    return not (self == other)
9776 vikram.rag 24910 
 
24911 
class getMarketPlaceItemsForPriceUpdate_args:
24912 
  """
24913 
  Attributes:
24914 
   - source
24915 
  """
24916 
 
24917 
  thrift_spec = (
24918 
    None, # 0
24919 
    (1, TType.I64, 'source', None, None, ), # 1
24920 
  )
24921 
 
24922 
  def __init__(self, source=None,):
24923 
    self.source = source
24924 
 
24925 
  def read(self, iprot):
24926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24928 
      return
24929 
    iprot.readStructBegin()
24930 
    while True:
24931 
      (fname, ftype, fid) = iprot.readFieldBegin()
24932 
      if ftype == TType.STOP:
24933 
        break
24934 
      if fid == 1:
24935 
        if ftype == TType.I64:
24936 
          self.source = iprot.readI64();
24937 
        else:
24938 
          iprot.skip(ftype)
24939 
      else:
24940 
        iprot.skip(ftype)
24941 
      iprot.readFieldEnd()
24942 
    iprot.readStructEnd()
24943 
 
24944 
  def write(self, oprot):
24945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24947 
      return
24948 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
24949 
    if self.source is not None:
24950 
      oprot.writeFieldBegin('source', TType.I64, 1)
24951 
      oprot.writeI64(self.source)
24952 
      oprot.writeFieldEnd()
24953 
    oprot.writeFieldStop()
24954 
    oprot.writeStructEnd()
24955 
 
24956 
  def validate(self):
24957 
    return
24958 
 
24959 
 
24960 
  def __repr__(self):
24961 
    L = ['%s=%r' % (key, value)
24962 
      for key, value in self.__dict__.iteritems()]
24963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24964 
 
24965 
  def __eq__(self, other):
24966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24967 
 
24968 
  def __ne__(self, other):
24969 
    return not (self == other)
24970 
 
24971 
class getMarketPlaceItemsForPriceUpdate_result:
24972 
  """
24973 
  Attributes:
24974 
   - success
24975 
  """
24976 
 
24977 
  thrift_spec = (
24978 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
24979 
  )
24980 
 
24981 
  def __init__(self, success=None,):
24982 
    self.success = success
24983 
 
24984 
  def read(self, iprot):
24985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24987 
      return
24988 
    iprot.readStructBegin()
24989 
    while True:
24990 
      (fname, ftype, fid) = iprot.readFieldBegin()
24991 
      if ftype == TType.STOP:
24992 
        break
24993 
      if fid == 0:
24994 
        if ftype == TType.LIST:
24995 
          self.success = []
24996 
          (_etype558, _size555) = iprot.readListBegin()
24997 
          for _i559 in xrange(_size555):
24998 
            _elem560 = MarketPlaceItemPrice()
24999 
            _elem560.read(iprot)
25000 
            self.success.append(_elem560)
25001 
          iprot.readListEnd()
25002 
        else:
25003 
          iprot.skip(ftype)
25004 
      else:
25005 
        iprot.skip(ftype)
25006 
      iprot.readFieldEnd()
25007 
    iprot.readStructEnd()
25008 
 
25009 
  def write(self, oprot):
25010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25012 
      return
25013 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25014 
    if self.success is not None:
25015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25017 
      for iter561 in self.success:
25018 
        iter561.write(oprot)
25019 
      oprot.writeListEnd()
25020 
      oprot.writeFieldEnd()
25021 
    oprot.writeFieldStop()
25022 
    oprot.writeStructEnd()
25023 
 
25024 
  def validate(self):
25025 
    return
25026 
 
25027 
 
25028 
  def __repr__(self):
25029 
    L = ['%s=%r' % (key, value)
25030 
      for key, value in self.__dict__.iteritems()]
25031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25032 
 
25033 
  def __eq__(self, other):
25034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25035 
 
25036 
  def __ne__(self, other):
25037 
    return not (self == other)
25038 
 
25039 
class updateMarketPlacePriceUpdateStatus_args:
25040 
  """
25041 
  Attributes:
25042 
   - skulist
25043 
   - timestamp
25044 
  """
25045 
 
25046 
  thrift_spec = (
25047 
    None, # 0
25048 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25049 
    (2, TType.I64, 'timestamp', None, None, ), # 2
25050 
  )
25051 
 
25052 
  def __init__(self, skulist=None, timestamp=None,):
25053 
    self.skulist = skulist
25054 
    self.timestamp = timestamp
25055 
 
25056 
  def read(self, iprot):
25057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25059 
      return
25060 
    iprot.readStructBegin()
25061 
    while True:
25062 
      (fname, ftype, fid) = iprot.readFieldBegin()
25063 
      if ftype == TType.STOP:
25064 
        break
25065 
      if fid == 1:
25066 
        if ftype == TType.LIST:
25067 
          self.skulist = []
25068 
          (_etype565, _size562) = iprot.readListBegin()
25069 
          for _i566 in xrange(_size562):
25070 
            _elem567 = iprot.readI64();
25071 
            self.skulist.append(_elem567)
25072 
          iprot.readListEnd()
25073 
        else:
25074 
          iprot.skip(ftype)
25075 
      elif fid == 2:
25076 
        if ftype == TType.I64:
25077 
          self.timestamp = iprot.readI64();
25078 
        else:
25079 
          iprot.skip(ftype)
25080 
      else:
25081 
        iprot.skip(ftype)
25082 
      iprot.readFieldEnd()
25083 
    iprot.readStructEnd()
25084 
 
25085 
  def write(self, oprot):
25086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25088 
      return
25089 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25090 
    if self.skulist is not None:
25091 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25092 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25093 
      for iter568 in self.skulist:
25094 
        oprot.writeI64(iter568)
25095 
      oprot.writeListEnd()
25096 
      oprot.writeFieldEnd()
25097 
    if self.timestamp is not None:
25098 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25099 
      oprot.writeI64(self.timestamp)
25100 
      oprot.writeFieldEnd()
25101 
    oprot.writeFieldStop()
25102 
    oprot.writeStructEnd()
25103 
 
25104 
  def validate(self):
25105 
    return
25106 
 
25107 
 
25108 
  def __repr__(self):
25109 
    L = ['%s=%r' % (key, value)
25110 
      for key, value in self.__dict__.iteritems()]
25111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25112 
 
25113 
  def __eq__(self, other):
25114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25115 
 
25116 
  def __ne__(self, other):
25117 
    return not (self == other)
25118 
 
25119 
class updateMarketPlacePriceUpdateStatus_result:
25120 
 
25121 
  thrift_spec = (
25122 
  )
25123 
 
25124 
  def read(self, iprot):
25125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25127 
      return
25128 
    iprot.readStructBegin()
25129 
    while True:
25130 
      (fname, ftype, fid) = iprot.readFieldBegin()
25131 
      if ftype == TType.STOP:
25132 
        break
25133 
      else:
25134 
        iprot.skip(ftype)
25135 
      iprot.readFieldEnd()
25136 
    iprot.readStructEnd()
25137 
 
25138 
  def write(self, oprot):
25139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25141 
      return
25142 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25143 
    oprot.writeFieldStop()
25144 
    oprot.writeStructEnd()
25145 
 
25146 
  def validate(self):
25147 
    return
25148 
 
25149 
 
25150 
  def __repr__(self):
25151 
    L = ['%s=%r' % (key, value)
25152 
      for key, value in self.__dict__.iteritems()]
25153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25154 
 
25155 
  def __eq__(self, other):
25156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25157 
 
25158 
  def __ne__(self, other):
25159 
    return not (self == other)