Subversion Repositories SmartDukaan

Rev

Rev 9242 | Rev 9299 | 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 
 
952 
 
5944 mandeep.dh 953 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
954 
  def __init__(self, iprot, oprot=None):
955 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
956 
 
957 
  def addItem(self, item):
958 
    """
959 
    Availability and inventory attributes
960 
 
961 
    Parameters:
962 
     - item
963 
    """
964 
    self.send_addItem(item)
965 
    return self.recv_addItem()
966 
 
967 
  def send_addItem(self, item):
968 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
969 
    args = addItem_args()
970 
    args.item = item
971 
    args.write(self._oprot)
972 
    self._oprot.writeMessageEnd()
973 
    self._oprot.trans.flush()
974 
 
975 
  def recv_addItem(self, ):
976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
977 
    if mtype == TMessageType.EXCEPTION:
978 
      x = TApplicationException()
979 
      x.read(self._iprot)
980 
      self._iprot.readMessageEnd()
981 
      raise x
982 
    result = addItem_result()
983 
    result.read(self._iprot)
984 
    self._iprot.readMessageEnd()
985 
    if result.success is not None:
986 
      return result.success
987 
    if result.cex is not None:
988 
      raise result.cex
989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
990 
 
991 
  def updateItem(self, item):
992 
    """
993 
    Parameters:
994 
     - item
995 
    """
996 
    self.send_updateItem(item)
997 
    return self.recv_updateItem()
998 
 
999 
  def send_updateItem(self, item):
1000 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1001 
    args = updateItem_args()
1002 
    args.item = item
1003 
    args.write(self._oprot)
1004 
    self._oprot.writeMessageEnd()
1005 
    self._oprot.trans.flush()
1006 
 
1007 
  def recv_updateItem(self, ):
1008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1009 
    if mtype == TMessageType.EXCEPTION:
1010 
      x = TApplicationException()
1011 
      x.read(self._iprot)
1012 
      self._iprot.readMessageEnd()
1013 
      raise x
1014 
    result = updateItem_result()
1015 
    result.read(self._iprot)
1016 
    self._iprot.readMessageEnd()
1017 
    if result.success is not None:
1018 
      return result.success
1019 
    if result.cex is not None:
1020 
      raise result.cex
1021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1022 
 
1023 
  def isActive(self, itemId):
1024 
    """
1025 
    Checks if the item given to the corresponding itemId is active. If it's active,
1026 
    whether it's risky and if it's risky, its inventory position.
1027 
 
1028 
    Parameters:
1029 
     - itemId
1030 
    """
1031 
    self.send_isActive(itemId)
1032 
    return self.recv_isActive()
1033 
 
1034 
  def send_isActive(self, itemId):
1035 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1036 
    args = isActive_args()
1037 
    args.itemId = itemId
1038 
    args.write(self._oprot)
1039 
    self._oprot.writeMessageEnd()
1040 
    self._oprot.trans.flush()
1041 
 
1042 
  def recv_isActive(self, ):
1043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1044 
    if mtype == TMessageType.EXCEPTION:
1045 
      x = TApplicationException()
1046 
      x.read(self._iprot)
1047 
      self._iprot.readMessageEnd()
1048 
      raise x
1049 
    result = isActive_result()
1050 
    result.read(self._iprot)
1051 
    self._iprot.readMessageEnd()
1052 
    if result.success is not None:
1053 
      return result.success
1054 
    if result.isex is not None:
1055 
      raise result.isex
1056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1057 
 
7438 amit.gupta 1058 
  def getItemsStatus(self, itemIds):
1059 
    """
1060 
    Parameters:
1061 
     - itemIds
1062 
    """
1063 
    self.send_getItemsStatus(itemIds)
1064 
    return self.recv_getItemsStatus()
1065 
 
1066 
  def send_getItemsStatus(self, itemIds):
1067 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1068 
    args = getItemsStatus_args()
1069 
    args.itemIds = itemIds
1070 
    args.write(self._oprot)
1071 
    self._oprot.writeMessageEnd()
1072 
    self._oprot.trans.flush()
1073 
 
1074 
  def recv_getItemsStatus(self, ):
1075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1076 
    if mtype == TMessageType.EXCEPTION:
1077 
      x = TApplicationException()
1078 
      x.read(self._iprot)
1079 
      self._iprot.readMessageEnd()
1080 
      raise x
1081 
    result = getItemsStatus_result()
1082 
    result.read(self._iprot)
1083 
    self._iprot.readMessageEnd()
1084 
    if result.success is not None:
1085 
      return result.success
1086 
    if result.isex is not None:
1087 
      raise result.isex
1088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1089 
 
5944 mandeep.dh 1090 
  def getItemStatusDescription(self, itemId):
1091 
    """
1092 
    Parameters:
1093 
     - itemId
1094 
    """
1095 
    self.send_getItemStatusDescription(itemId)
1096 
    return self.recv_getItemStatusDescription()
1097 
 
1098 
  def send_getItemStatusDescription(self, itemId):
1099 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1100 
    args = getItemStatusDescription_args()
1101 
    args.itemId = itemId
1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_getItemStatusDescription(self, ):
1107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1108 
    if mtype == TMessageType.EXCEPTION:
1109 
      x = TApplicationException()
1110 
      x.read(self._iprot)
1111 
      self._iprot.readMessageEnd()
1112 
      raise x
1113 
    result = getItemStatusDescription_result()
1114 
    result.read(self._iprot)
1115 
    self._iprot.readMessageEnd()
1116 
    if result.success is not None:
1117 
      return result.success
1118 
    if result.isex is not None:
1119 
      raise result.isex
1120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1121 
 
1122 
  def startItemOn(self, item_id, timestamp):
1123 
    """
1124 
    Parameters:
1125 
     - item_id
1126 
     - timestamp
1127 
    """
1128 
    self.send_startItemOn(item_id, timestamp)
1129 
    self.recv_startItemOn()
1130 
 
1131 
  def send_startItemOn(self, item_id, timestamp):
1132 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1133 
    args = startItemOn_args()
1134 
    args.item_id = item_id
1135 
    args.timestamp = timestamp
1136 
    args.write(self._oprot)
1137 
    self._oprot.writeMessageEnd()
1138 
    self._oprot.trans.flush()
1139 
 
1140 
  def recv_startItemOn(self, ):
1141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1142 
    if mtype == TMessageType.EXCEPTION:
1143 
      x = TApplicationException()
1144 
      x.read(self._iprot)
1145 
      self._iprot.readMessageEnd()
1146 
      raise x
1147 
    result = startItemOn_result()
1148 
    result.read(self._iprot)
1149 
    self._iprot.readMessageEnd()
1150 
    if result.cex is not None:
1151 
      raise result.cex
1152 
    return
1153 
 
1154 
  def retireItemOn(self, item_id, timestamp):
1155 
    """
1156 
    Parameters:
1157 
     - item_id
1158 
     - timestamp
1159 
    """
1160 
    self.send_retireItemOn(item_id, timestamp)
1161 
    self.recv_retireItemOn()
1162 
 
1163 
  def send_retireItemOn(self, item_id, timestamp):
1164 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1165 
    args = retireItemOn_args()
1166 
    args.item_id = item_id
1167 
    args.timestamp = timestamp
1168 
    args.write(self._oprot)
1169 
    self._oprot.writeMessageEnd()
1170 
    self._oprot.trans.flush()
1171 
 
1172 
  def recv_retireItemOn(self, ):
1173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1174 
    if mtype == TMessageType.EXCEPTION:
1175 
      x = TApplicationException()
1176 
      x.read(self._iprot)
1177 
      self._iprot.readMessageEnd()
1178 
      raise x
1179 
    result = retireItemOn_result()
1180 
    result.read(self._iprot)
1181 
    self._iprot.readMessageEnd()
1182 
    if result.cex is not None:
1183 
      raise result.cex
1184 
    return
1185 
 
1186 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1187 
    """
1188 
    Parameters:
1189 
     - item_id
1190 
     - timestamp
1191 
     - newstatus
1192 
    """
1193 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1194 
    self.recv_changeItemStatus()
1195 
 
1196 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1197 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1198 
    args = changeItemStatus_args()
1199 
    args.item_id = item_id
1200 
    args.timestamp = timestamp
1201 
    args.newstatus = newstatus
1202 
    args.write(self._oprot)
1203 
    self._oprot.writeMessageEnd()
1204 
    self._oprot.trans.flush()
1205 
 
1206 
  def recv_changeItemStatus(self, ):
1207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1208 
    if mtype == TMessageType.EXCEPTION:
1209 
      x = TApplicationException()
1210 
      x.read(self._iprot)
1211 
      self._iprot.readMessageEnd()
1212 
      raise x
1213 
    result = changeItemStatus_result()
1214 
    result.read(self._iprot)
1215 
    self._iprot.readMessageEnd()
1216 
    if result.cex is not None:
1217 
      raise result.cex
1218 
    return
1219 
 
1220 
  def getItem(self, item_id):
1221 
    """
1222 
    Parameters:
1223 
     - item_id
1224 
    """
1225 
    self.send_getItem(item_id)
1226 
    return self.recv_getItem()
1227 
 
1228 
  def send_getItem(self, item_id):
1229 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1230 
    args = getItem_args()
1231 
    args.item_id = item_id
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1236 
  def recv_getItem(self, ):
1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1243 
    result = getItem_result()
1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
1246 
    if result.success is not None:
1247 
      return result.success
1248 
    if result.cex is not None:
1249 
      raise result.cex
1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1251 
 
1252 
  def getItemsByCatalogId(self, catalog_item_id):
1253 
    """
1254 
    Parameters:
1255 
     - catalog_item_id
1256 
    """
1257 
    self.send_getItemsByCatalogId(catalog_item_id)
1258 
    return self.recv_getItemsByCatalogId()
1259 
 
1260 
  def send_getItemsByCatalogId(self, catalog_item_id):
1261 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1262 
    args = getItemsByCatalogId_args()
1263 
    args.catalog_item_id = catalog_item_id
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getItemsByCatalogId(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getItemsByCatalogId_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
1278 
    if result.success is not None:
1279 
      return result.success
1280 
    if result.cex is not None:
1281 
      raise result.cex
1282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1283 
 
1284 
  def getValidItemsByCatalogId(self, catalog_item_id):
1285 
    """
1286 
    Parameters:
1287 
     - catalog_item_id
1288 
    """
1289 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1290 
    return self.recv_getValidItemsByCatalogId()
1291 
 
1292 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1293 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1294 
    args = getValidItemsByCatalogId_args()
1295 
    args.catalog_item_id = catalog_item_id
1296 
    args.write(self._oprot)
1297 
    self._oprot.writeMessageEnd()
1298 
    self._oprot.trans.flush()
1299 
 
1300 
  def recv_getValidItemsByCatalogId(self, ):
1301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1302 
    if mtype == TMessageType.EXCEPTION:
1303 
      x = TApplicationException()
1304 
      x.read(self._iprot)
1305 
      self._iprot.readMessageEnd()
1306 
      raise x
1307 
    result = getValidItemsByCatalogId_result()
1308 
    result.read(self._iprot)
1309 
    self._iprot.readMessageEnd()
1310 
    if result.success is not None:
1311 
      return result.success
1312 
    if result.cex is not None:
1313 
      raise result.cex
1314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1315 
 
1316 
  def getAllItems(self, isActive):
1317 
    """
1318 
    Parameters:
1319 
     - isActive
1320 
    """
1321 
    self.send_getAllItems(isActive)
1322 
    return self.recv_getAllItems()
1323 
 
1324 
  def send_getAllItems(self, isActive):
1325 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1326 
    args = getAllItems_args()
1327 
    args.isActive = isActive
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getAllItems(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getAllItems_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
1342 
    if result.success is not None:
1343 
      return result.success
1344 
    if result.cex is not None:
1345 
      raise result.cex
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1347 
 
1348 
  def getAllItemsByStatus(self, itemStatus):
1349 
    """
1350 
    Parameters:
1351 
     - itemStatus
1352 
    """
1353 
    self.send_getAllItemsByStatus(itemStatus)
1354 
    return self.recv_getAllItemsByStatus()
1355 
 
1356 
  def send_getAllItemsByStatus(self, itemStatus):
1357 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1358 
    args = getAllItemsByStatus_args()
1359 
    args.itemStatus = itemStatus
1360 
    args.write(self._oprot)
1361 
    self._oprot.writeMessageEnd()
1362 
    self._oprot.trans.flush()
1363 
 
1364 
  def recv_getAllItemsByStatus(self, ):
1365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1366 
    if mtype == TMessageType.EXCEPTION:
1367 
      x = TApplicationException()
1368 
      x.read(self._iprot)
1369 
      self._iprot.readMessageEnd()
1370 
      raise x
1371 
    result = getAllItemsByStatus_result()
1372 
    result.read(self._iprot)
1373 
    self._iprot.readMessageEnd()
1374 
    if result.success is not None:
1375 
      return result.success
1376 
    if result.cex is not None:
1377 
      raise result.cex
1378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1379 
 
9253 rajveer 1380 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1381 
    """
1382 
    Parameters:
1383 
     - entityId
1384 
     - category
1385 
     - brand
1386 
     - modelName
1387 
     - modelNumber
9253 rajveer 1388 
     - isAndroid
5944 mandeep.dh 1389 
    """
9253 rajveer 1390 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1391 
    return self.recv_markItemAsContentComplete()
1392 
 
9253 rajveer 1393 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1394 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1395 
    args = markItemAsContentComplete_args()
1396 
    args.entityId = entityId
1397 
    args.category = category
1398 
    args.brand = brand
1399 
    args.modelName = modelName
1400 
    args.modelNumber = modelNumber
9253 rajveer 1401 
    args.isAndroid = isAndroid
5944 mandeep.dh 1402 
    args.write(self._oprot)
1403 
    self._oprot.writeMessageEnd()
1404 
    self._oprot.trans.flush()
1405 
 
1406 
  def recv_markItemAsContentComplete(self, ):
1407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1408 
    if mtype == TMessageType.EXCEPTION:
1409 
      x = TApplicationException()
1410 
      x.read(self._iprot)
1411 
      self._iprot.readMessageEnd()
1412 
      raise x
1413 
    result = markItemAsContentComplete_result()
1414 
    result.read(self._iprot)
1415 
    self._iprot.readMessageEnd()
1416 
    if result.success is not None:
1417 
      return result.success
1418 
    if result.cex is not None:
1419 
      raise result.cex
1420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1421 
 
1422 
  def getAllItemsInRange(self, offset, limit):
1423 
    """
1424 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1425 
 
1426 
    Parameters:
1427 
     - offset
1428 
     - limit
1429 
    """
1430 
    self.send_getAllItemsInRange(offset, limit)
1431 
    return self.recv_getAllItemsInRange()
1432 
 
1433 
  def send_getAllItemsInRange(self, offset, limit):
1434 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1435 
    args = getAllItemsInRange_args()
1436 
    args.offset = offset
1437 
    args.limit = limit
1438 
    args.write(self._oprot)
1439 
    self._oprot.writeMessageEnd()
1440 
    self._oprot.trans.flush()
1441 
 
1442 
  def recv_getAllItemsInRange(self, ):
1443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1444 
    if mtype == TMessageType.EXCEPTION:
1445 
      x = TApplicationException()
1446 
      x.read(self._iprot)
1447 
      self._iprot.readMessageEnd()
1448 
      raise x
1449 
    result = getAllItemsInRange_result()
1450 
    result.read(self._iprot)
1451 
    self._iprot.readMessageEnd()
1452 
    if result.success is not None:
1453 
      return result.success
1454 
    if result.cex is not None:
1455 
      raise result.cex
1456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1457 
 
1458 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1459 
    """
1460 
    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.
1461 
 
1462 
    Parameters:
1463 
     - itemStatus
1464 
     - offset
1465 
     - limit
1466 
    """
1467 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1468 
    return self.recv_getAllItemsByStatusInRange()
1469 
 
1470 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1471 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1472 
    args = getAllItemsByStatusInRange_args()
1473 
    args.itemStatus = itemStatus
1474 
    args.offset = offset
1475 
    args.limit = limit
1476 
    args.write(self._oprot)
1477 
    self._oprot.writeMessageEnd()
1478 
    self._oprot.trans.flush()
1479 
 
1480 
  def recv_getAllItemsByStatusInRange(self, ):
1481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1482 
    if mtype == TMessageType.EXCEPTION:
1483 
      x = TApplicationException()
1484 
      x.read(self._iprot)
1485 
      self._iprot.readMessageEnd()
1486 
      raise x
1487 
    result = getAllItemsByStatusInRange_result()
1488 
    result.read(self._iprot)
1489 
    self._iprot.readMessageEnd()
1490 
    if result.success is not None:
1491 
      return result.success
1492 
    if result.cex is not None:
1493 
      raise result.cex
1494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1495 
 
1496 
  def getItemCountByStatus(self, useStatus, itemStatus):
1497 
    """
1498 
    Gets a count of all items by status
1499 
 
1500 
    Parameters:
1501 
     - useStatus
1502 
     - itemStatus
1503 
    """
1504 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1505 
    return self.recv_getItemCountByStatus()
1506 
 
1507 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1508 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1509 
    args = getItemCountByStatus_args()
1510 
    args.useStatus = useStatus
1511 
    args.itemStatus = itemStatus
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getItemCountByStatus(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getItemCountByStatus_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
1526 
    if result.success is not None:
1527 
      return result.success
1528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1529 
 
1530 
  def getBestSellers(self, ):
1531 
    self.send_getBestSellers()
1532 
    return self.recv_getBestSellers()
1533 
 
1534 
  def send_getBestSellers(self, ):
1535 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1536 
    args = getBestSellers_args()
1537 
    args.write(self._oprot)
1538 
    self._oprot.writeMessageEnd()
1539 
    self._oprot.trans.flush()
1540 
 
1541 
  def recv_getBestSellers(self, ):
1542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1543 
    if mtype == TMessageType.EXCEPTION:
1544 
      x = TApplicationException()
1545 
      x.read(self._iprot)
1546 
      self._iprot.readMessageEnd()
1547 
      raise x
1548 
    result = getBestSellers_result()
1549 
    result.read(self._iprot)
1550 
    self._iprot.readMessageEnd()
1551 
    if result.success is not None:
1552 
      return result.success
1553 
    if result.isex is not None:
1554 
      raise result.isex
1555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1556 
 
1557 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1558 
    """
1559 
    Parameters:
1560 
     - beginIndex
1561 
     - totalItems
1562 
     - brand
1563 
     - category
1564 
    """
1565 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1566 
    return self.recv_getBestSellersCatalogIds()
1567 
 
1568 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1569 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1570 
    args = getBestSellersCatalogIds_args()
1571 
    args.beginIndex = beginIndex
1572 
    args.totalItems = totalItems
1573 
    args.brand = brand
1574 
    args.category = category
1575 
    args.write(self._oprot)
1576 
    self._oprot.writeMessageEnd()
1577 
    self._oprot.trans.flush()
1578 
 
1579 
  def recv_getBestSellersCatalogIds(self, ):
1580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1581 
    if mtype == TMessageType.EXCEPTION:
1582 
      x = TApplicationException()
1583 
      x.read(self._iprot)
1584 
      self._iprot.readMessageEnd()
1585 
      raise x
1586 
    result = getBestSellersCatalogIds_result()
1587 
    result.read(self._iprot)
1588 
    self._iprot.readMessageEnd()
1589 
    if result.success is not None:
1590 
      return result.success
1591 
    if result.cex is not None:
1592 
      raise result.cex
1593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1594 
 
1595 
  def getBestSellersCount(self, ):
1596 
    self.send_getBestSellersCount()
1597 
    return self.recv_getBestSellersCount()
1598 
 
1599 
  def send_getBestSellersCount(self, ):
1600 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1601 
    args = getBestSellersCount_args()
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getBestSellersCount(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getBestSellersCount_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
1616 
    if result.success is not None:
1617 
      return result.success
1618 
    if result.cex is not None:
1619 
      raise result.cex
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1621 
 
1622 
  def getBestDeals(self, ):
1623 
    self.send_getBestDeals()
1624 
    return self.recv_getBestDeals()
1625 
 
1626 
  def send_getBestDeals(self, ):
1627 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1628 
    args = getBestDeals_args()
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getBestDeals(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getBestDeals_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
1643 
    if result.success is not None:
1644 
      return result.success
1645 
    if result.isex is not None:
1646 
      raise result.isex
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1648 
 
1649 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1650 
    """
1651 
    Parameters:
1652 
     - beginIndex
1653 
     - totalItems
1654 
     - brand
1655 
     - category
1656 
    """
1657 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1658 
    return self.recv_getBestDealsCatalogIds()
1659 
 
1660 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1661 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1662 
    args = getBestDealsCatalogIds_args()
1663 
    args.beginIndex = beginIndex
1664 
    args.totalItems = totalItems
1665 
    args.brand = brand
1666 
    args.category = category
1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1671 
  def recv_getBestDealsCatalogIds(self, ):
1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1678 
    result = getBestDealsCatalogIds_result()
1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
1681 
    if result.success is not None:
1682 
      return result.success
1683 
    if result.cex is not None:
1684 
      raise result.cex
1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1686 
 
1687 
  def getBestDealsCount(self, ):
1688 
    self.send_getBestDealsCount()
1689 
    return self.recv_getBestDealsCount()
1690 
 
1691 
  def send_getBestDealsCount(self, ):
1692 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1693 
    args = getBestDealsCount_args()
1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1698 
  def recv_getBestDealsCount(self, ):
1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1705 
    result = getBestDealsCount_result()
1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
1708 
    if result.success is not None:
1709 
      return result.success
1710 
    if result.cex is not None:
1711 
      raise result.cex
1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1713 
 
1714 
  def getComingSoon(self, ):
1715 
    self.send_getComingSoon()
1716 
    return self.recv_getComingSoon()
1717 
 
1718 
  def send_getComingSoon(self, ):
1719 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1720 
    args = getComingSoon_args()
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getComingSoon(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getComingSoon_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
1735 
    if result.success is not None:
1736 
      return result.success
1737 
    if result.isex is not None:
1738 
      raise result.isex
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1740 
 
1741 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1742 
    """
1743 
    Parameters:
1744 
     - beginIndex
1745 
     - totalItems
1746 
     - brand
1747 
     - category
1748 
    """
1749 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1750 
    return self.recv_getComingSoonCatalogIds()
1751 
 
1752 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1753 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1754 
    args = getComingSoonCatalogIds_args()
1755 
    args.beginIndex = beginIndex
1756 
    args.totalItems = totalItems
1757 
    args.brand = brand
1758 
    args.category = category
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getComingSoonCatalogIds(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getComingSoonCatalogIds_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success is not None:
1774 
      return result.success
1775 
    if result.cex is not None:
1776 
      raise result.cex
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1778 
 
1779 
  def getComingSoonCount(self, ):
1780 
    self.send_getComingSoonCount()
1781 
    return self.recv_getComingSoonCount()
1782 
 
1783 
  def send_getComingSoonCount(self, ):
1784 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1785 
    args = getComingSoonCount_args()
1786 
    args.write(self._oprot)
1787 
    self._oprot.writeMessageEnd()
1788 
    self._oprot.trans.flush()
1789 
 
1790 
  def recv_getComingSoonCount(self, ):
1791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1792 
    if mtype == TMessageType.EXCEPTION:
1793 
      x = TApplicationException()
1794 
      x.read(self._iprot)
1795 
      self._iprot.readMessageEnd()
1796 
      raise x
1797 
    result = getComingSoonCount_result()
1798 
    result.read(self._iprot)
1799 
    self._iprot.readMessageEnd()
1800 
    if result.success is not None:
1801 
      return result.success
1802 
    if result.cex is not None:
1803 
      raise result.cex
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1805 
 
1806 
  def getLatestArrivals(self, ):
1807 
    """
1808 
    Returns a list of items sorted in the descending order by start date.
1809 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1810 
    """
1811 
    self.send_getLatestArrivals()
1812 
    return self.recv_getLatestArrivals()
1813 
 
1814 
  def send_getLatestArrivals(self, ):
1815 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1816 
    args = getLatestArrivals_args()
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_getLatestArrivals(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = getLatestArrivals_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.success is not None:
1832 
      return result.success
1833 
    if result.isex is not None:
1834 
      raise result.isex
1835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1836 
 
1837 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1838 
    """
1839 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1840 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1841 
 
1842 
    Parameters:
1843 
     - beginIndex
1844 
     - totalItems
1845 
     - brand
1846 
     - categories
1847 
    """
1848 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1849 
    return self.recv_getLatestArrivalsCatalogIds()
1850 
 
1851 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1852 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1853 
    args = getLatestArrivalsCatalogIds_args()
1854 
    args.beginIndex = beginIndex
1855 
    args.totalItems = totalItems
1856 
    args.brand = brand
1857 
    args.categories = categories
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_getLatestArrivalsCatalogIds(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = getLatestArrivalsCatalogIds_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    if result.success is not None:
1873 
      return result.success
1874 
    if result.cex is not None:
1875 
      raise result.cex
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1877 
 
1878 
  def getLatestArrivalsCount(self, ):
1879 
    """
1880 
    Get the total number of latest arrivals we are willing to show.
1881 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1882 
    """
1883 
    self.send_getLatestArrivalsCount()
1884 
    return self.recv_getLatestArrivalsCount()
1885 
 
1886 
  def send_getLatestArrivalsCount(self, ):
1887 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1888 
    args = getLatestArrivalsCount_args()
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_getLatestArrivalsCount(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = getLatestArrivalsCount_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
1903 
    if result.success is not None:
1904 
      return result.success
1905 
    if result.cex is not None:
1906 
      raise result.cex
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1908 
 
1909 
  def generateNewEntityID(self, ):
1910 
    self.send_generateNewEntityID()
1911 
    return self.recv_generateNewEntityID()
1912 
 
1913 
  def send_generateNewEntityID(self, ):
1914 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1915 
    args = generateNewEntityID_args()
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_generateNewEntityID(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = generateNewEntityID_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success is not None:
1931 
      return result.success
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1933 
 
1934 
  def addCategory(self, category):
1935 
    """
1936 
    All category related functions
1937 
 
1938 
    Parameters:
1939 
     - category
1940 
    """
1941 
    self.send_addCategory(category)
1942 
    return self.recv_addCategory()
1943 
 
1944 
  def send_addCategory(self, category):
1945 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1946 
    args = addCategory_args()
1947 
    args.category = category
1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
1952 
  def recv_addCategory(self, ):
1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
1959 
    result = addCategory_result()
1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success is not None:
1963 
      return result.success
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1965 
 
1966 
  def getCategory(self, id):
1967 
    """
1968 
    Parameters:
1969 
     - id
1970 
    """
1971 
    self.send_getCategory(id)
1972 
    return self.recv_getCategory()
1973 
 
1974 
  def send_getCategory(self, id):
1975 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1976 
    args = getCategory_args()
1977 
    args.id = id
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getCategory(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getCategory_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
1992 
    if result.success is not None:
1993 
      return result.success
1994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1995 
 
1996 
  def getAllCategories(self, ):
1997 
    self.send_getAllCategories()
1998 
    return self.recv_getAllCategories()
1999 
 
2000 
  def send_getAllCategories(self, ):
2001 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2002 
    args = getAllCategories_args()
2003 
    args.write(self._oprot)
2004 
    self._oprot.writeMessageEnd()
2005 
    self._oprot.trans.flush()
2006 
 
2007 
  def recv_getAllCategories(self, ):
2008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2009 
    if mtype == TMessageType.EXCEPTION:
2010 
      x = TApplicationException()
2011 
      x.read(self._iprot)
2012 
      self._iprot.readMessageEnd()
2013 
      raise x
2014 
    result = getAllCategories_result()
2015 
    result.read(self._iprot)
2016 
    self._iprot.readMessageEnd()
2017 
    if result.success is not None:
2018 
      return result.success
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2020 
 
2021 
  def getAllSimilarItems(self, itemId):
2022 
    """
2023 
    Returns the list of similar items.
2024 
 
2025 
    Parameters:
2026 
     - itemId
2027 
    """
2028 
    self.send_getAllSimilarItems(itemId)
2029 
    return self.recv_getAllSimilarItems()
2030 
 
2031 
  def send_getAllSimilarItems(self, itemId):
2032 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2033 
    args = getAllSimilarItems_args()
2034 
    args.itemId = itemId
2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
2039 
  def recv_getAllSimilarItems(self, ):
2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
2046 
    result = getAllSimilarItems_result()
2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
2049 
    if result.success is not None:
2050 
      return result.success
2051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2052 
 
2053 
  def addSimilarItem(self, itemId, catalogItemId):
2054 
    """
2055 
    Adds similar item.
2056 
 
2057 
    Parameters:
2058 
     - itemId
2059 
     - catalogItemId
2060 
    """
2061 
    self.send_addSimilarItem(itemId, catalogItemId)
2062 
    return self.recv_addSimilarItem()
2063 
 
2064 
  def send_addSimilarItem(self, itemId, catalogItemId):
2065 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2066 
    args = addSimilarItem_args()
2067 
    args.itemId = itemId
2068 
    args.catalogItemId = catalogItemId
2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
2073 
  def recv_addSimilarItem(self, ):
2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
2080 
    result = addSimilarItem_result()
2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
2083 
    if result.success is not None:
2084 
      return result.success
2085 
    if result.cex is not None:
2086 
      raise result.cex
2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2088 
 
6512 kshitij.so 2089 
  def addTag(self, displayName, itemId):
2090 
    """
2091 
    Tag Related
2092 
 
2093 
    Parameters:
2094 
     - displayName
2095 
     - itemId
2096 
    """
2097 
    self.send_addTag(displayName, itemId)
2098 
    return self.recv_addTag()
2099 
 
2100 
  def send_addTag(self, displayName, itemId):
2101 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2102 
    args = addTag_args()
2103 
    args.displayName = displayName
2104 
    args.itemId = itemId
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_addTag(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = addTag_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
2119 
    if result.success is not None:
2120 
      return result.success
2121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2122 
 
2123 
  def deleteEntityTag(self, displayName, itemId):
2124 
    """
2125 
    Parameters:
2126 
     - displayName
2127 
     - itemId
2128 
    """
2129 
    self.send_deleteEntityTag(displayName, itemId)
2130 
    return self.recv_deleteEntityTag()
2131 
 
2132 
  def send_deleteEntityTag(self, displayName, itemId):
2133 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2134 
    args = deleteEntityTag_args()
2135 
    args.displayName = displayName
2136 
    args.itemId = itemId
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
2141 
  def recv_deleteEntityTag(self, ):
2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
2148 
    result = deleteEntityTag_result()
2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
2151 
    if result.success is not None:
2152 
      return result.success
2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2154 
 
2155 
  def deleteTag(self, displayName):
2156 
    """
2157 
    Parameters:
2158 
     - displayName
2159 
    """
2160 
    self.send_deleteTag(displayName)
2161 
    return self.recv_deleteTag()
2162 
 
2163 
  def send_deleteTag(self, displayName):
2164 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2165 
    args = deleteTag_args()
2166 
    args.displayName = displayName
2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
2171 
  def recv_deleteTag(self, ):
2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
2178 
    result = deleteTag_result()
2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
2181 
    if result.success is not None:
2182 
      return result.success
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2184 
 
2185 
  def getAllTags(self, ):
2186 
    self.send_getAllTags()
2187 
    return self.recv_getAllTags()
2188 
 
2189 
  def send_getAllTags(self, ):
2190 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2191 
    args = getAllTags_args()
2192 
    args.write(self._oprot)
2193 
    self._oprot.writeMessageEnd()
2194 
    self._oprot.trans.flush()
2195 
 
2196 
  def recv_getAllTags(self, ):
2197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2198 
    if mtype == TMessageType.EXCEPTION:
2199 
      x = TApplicationException()
2200 
      x.read(self._iprot)
2201 
      self._iprot.readMessageEnd()
2202 
      raise x
2203 
    result = getAllTags_result()
2204 
    result.read(self._iprot)
2205 
    self._iprot.readMessageEnd()
2206 
    if result.success is not None:
2207 
      return result.success
2208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2209 
 
2210 
  def getAllEntitiesByTagName(self, displayName):
2211 
    """
2212 
    Parameters:
2213 
     - displayName
2214 
    """
2215 
    self.send_getAllEntitiesByTagName(displayName)
2216 
    return self.recv_getAllEntitiesByTagName()
2217 
 
2218 
  def send_getAllEntitiesByTagName(self, displayName):
2219 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2220 
    args = getAllEntitiesByTagName_args()
2221 
    args.displayName = displayName
2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
2226 
  def recv_getAllEntitiesByTagName(self, ):
2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
2233 
    result = getAllEntitiesByTagName_result()
2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
2236 
    if result.success is not None:
2237 
      return result.success
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2239 
 
6845 amit.gupta 2240 
  def getAllEntityTags(self, ):
2241 
    self.send_getAllEntityTags()
2242 
    return self.recv_getAllEntityTags()
2243 
 
2244 
  def send_getAllEntityTags(self, ):
2245 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2246 
    args = getAllEntityTags_args()
2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2251 
  def recv_getAllEntityTags(self, ):
2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2258 
    result = getAllEntityTags_result()
2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
2261 
    if result.success is not None:
2262 
      return result.success
2263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2264 
 
8590 kshitij.so 2265 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2266 
    """
8579 kshitij.so 2267 
    Banner Related
2268 
 
6850 kshitij.so 2269 
    Parameters:
8590 kshitij.so 2270 
     - bannerCongregate
6850 kshitij.so 2271 
    """
8590 kshitij.so 2272 
    self.send_addBanner(bannerCongregate)
2273 
    self.recv_addBanner()
6850 kshitij.so 2274 
 
8590 kshitij.so 2275 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2276 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2277 
    args = addBanner_args()
8590 kshitij.so 2278 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2279 
    args.write(self._oprot)
2280 
    self._oprot.writeMessageEnd()
2281 
    self._oprot.trans.flush()
2282 
 
2283 
  def recv_addBanner(self, ):
2284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2285 
    if mtype == TMessageType.EXCEPTION:
2286 
      x = TApplicationException()
2287 
      x.read(self._iprot)
2288 
      self._iprot.readMessageEnd()
2289 
      raise x
2290 
    result = addBanner_result()
2291 
    result.read(self._iprot)
2292 
    self._iprot.readMessageEnd()
8590 kshitij.so 2293 
    return
6850 kshitij.so 2294 
 
8579 kshitij.so 2295 
  def updateBanner(self, banner):
2296 
    """
2297 
    Parameters:
2298 
     - banner
2299 
    """
2300 
    self.send_updateBanner(banner)
2301 
    return self.recv_updateBanner()
2302 
 
2303 
  def send_updateBanner(self, banner):
2304 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2305 
    args = updateBanner_args()
2306 
    args.banner = banner
2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_updateBanner(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = updateBanner_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
2321 
    if result.success is not None:
2322 
      return result.success
2323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2324 
 
6850 kshitij.so 2325 
  def getAllBanners(self, ):
2326 
    self.send_getAllBanners()
2327 
    return self.recv_getAllBanners()
2328 
 
2329 
  def send_getAllBanners(self, ):
2330 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2331 
    args = getAllBanners_args()
2332 
    args.write(self._oprot)
2333 
    self._oprot.writeMessageEnd()
2334 
    self._oprot.trans.flush()
2335 
 
2336 
  def recv_getAllBanners(self, ):
2337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2338 
    if mtype == TMessageType.EXCEPTION:
2339 
      x = TApplicationException()
2340 
      x.read(self._iprot)
2341 
      self._iprot.readMessageEnd()
2342 
      raise x
2343 
    result = getAllBanners_result()
2344 
    result.read(self._iprot)
2345 
    self._iprot.readMessageEnd()
2346 
    if result.success is not None:
2347 
      return result.success
2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2349 
 
9155 kshitij.so 2350 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2351 
    """
2352 
    Parameters:
2353 
     - bannerName
9155 kshitij.so 2354 
     - bannerType
6850 kshitij.so 2355 
    """
9155 kshitij.so 2356 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2357 
    return self.recv_deleteBanner()
2358 
 
9155 kshitij.so 2359 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2360 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2361 
    args = deleteBanner_args()
2362 
    args.bannerName = bannerName
9155 kshitij.so 2363 
    args.bannerType = bannerType
6850 kshitij.so 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_deleteBanner(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = deleteBanner_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.success is not None:
2379 
      return result.success
2380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2381 
 
9155 kshitij.so 2382 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2383 
    """
2384 
    Parameters:
2385 
     - bannerName
9155 kshitij.so 2386 
     - bannerType
6850 kshitij.so 2387 
    """
9155 kshitij.so 2388 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2389 
    return self.recv_getBannerDetails()
2390 
 
9155 kshitij.so 2391 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2392 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2393 
    args = getBannerDetails_args()
2394 
    args.bannerName = bannerName
9155 kshitij.so 2395 
    args.bannerType = bannerType
6850 kshitij.so 2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
2400 
  def recv_getBannerDetails(self, ):
2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
2407 
    result = getBannerDetails_result()
2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
2410 
    if result.success is not None:
2411 
      return result.success
2412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2413 
 
2414 
  def getActiveBanners(self, ):
2415 
    self.send_getActiveBanners()
2416 
    return self.recv_getActiveBanners()
2417 
 
2418 
  def send_getActiveBanners(self, ):
2419 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2420 
    args = getActiveBanners_args()
2421 
    args.write(self._oprot)
2422 
    self._oprot.writeMessageEnd()
2423 
    self._oprot.trans.flush()
2424 
 
2425 
  def recv_getActiveBanners(self, ):
2426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2427 
    if mtype == TMessageType.EXCEPTION:
2428 
      x = TApplicationException()
2429 
      x.read(self._iprot)
2430 
      self._iprot.readMessageEnd()
2431 
      raise x
2432 
    result = getActiveBanners_result()
2433 
    result.read(self._iprot)
2434 
    self._iprot.readMessageEnd()
2435 
    if result.success is not None:
2436 
      return result.success
2437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2438 
 
8579 kshitij.so 2439 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2440 
    """
2441 
    Parameters:
8579 kshitij.so 2442 
     - bannerMaps
6849 kshitij.so 2443 
    """
8579 kshitij.so 2444 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2445 
    return self.recv_addBannerMap()
2446 
 
8579 kshitij.so 2447 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2448 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2449 
    args = addBannerMap_args()
8579 kshitij.so 2450 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2451 
    args.write(self._oprot)
2452 
    self._oprot.writeMessageEnd()
2453 
    self._oprot.trans.flush()
2454 
 
2455 
  def recv_addBannerMap(self, ):
2456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2457 
    if mtype == TMessageType.EXCEPTION:
2458 
      x = TApplicationException()
2459 
      x.read(self._iprot)
2460 
      self._iprot.readMessageEnd()
2461 
      raise x
2462 
    result = addBannerMap_result()
2463 
    result.read(self._iprot)
2464 
    self._iprot.readMessageEnd()
2465 
    if result.success is not None:
2466 
      return result.success
2467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2468 
 
8579 kshitij.so 2469 
  def updateBannerMap(self, bannerMap):
2470 
    """
2471 
    Parameters:
2472 
     - bannerMap
2473 
    """
2474 
    self.send_updateBannerMap(bannerMap)
2475 
    return self.recv_updateBannerMap()
2476 
 
2477 
  def send_updateBannerMap(self, bannerMap):
2478 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2479 
    args = updateBannerMap_args()
2480 
    args.bannerMap = bannerMap
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_updateBannerMap(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = updateBannerMap_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
2495 
    if result.success is not None:
2496 
      return result.success
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2498 
 
6849 kshitij.so 2499 
  def deleteBannerMap(self, bannerName):
2500 
    """
2501 
    Parameters:
2502 
     - bannerName
2503 
    """
2504 
    self.send_deleteBannerMap(bannerName)
2505 
    return self.recv_deleteBannerMap()
2506 
 
2507 
  def send_deleteBannerMap(self, bannerName):
2508 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2509 
    args = deleteBannerMap_args()
2510 
    args.bannerName = bannerName
2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2515 
  def recv_deleteBannerMap(self, ):
2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2522 
    result = deleteBannerMap_result()
2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
2525 
    if result.success is not None:
2526 
      return result.success
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2528 
 
9155 kshitij.so 2529 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2530 
    """
2531 
    Parameters:
2532 
     - bannerName
9155 kshitij.so 2533 
     - bannerType
6849 kshitij.so 2534 
    """
9155 kshitij.so 2535 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2536 
    return self.recv_getBannerMapDetails()
2537 
 
9155 kshitij.so 2538 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2539 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2540 
    args = getBannerMapDetails_args()
2541 
    args.bannerName = bannerName
9155 kshitij.so 2542 
    args.bannerType = bannerType
6849 kshitij.so 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_getBannerMapDetails(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = getBannerMapDetails_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2560 
 
8579 kshitij.so 2561 
  def addBannerUri(self, bannerUriMappings):
2562 
    """
2563 
    Parameters:
2564 
     - bannerUriMappings
2565 
    """
2566 
    self.send_addBannerUri(bannerUriMappings)
2567 
    self.recv_addBannerUri()
2568 
 
2569 
  def send_addBannerUri(self, bannerUriMappings):
2570 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2571 
    args = addBannerUri_args()
2572 
    args.bannerUriMappings = bannerUriMappings
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_addBannerUri(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = addBannerUri_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    return
2588 
 
9155 kshitij.so 2589 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2590 
    """
2591 
    Parameters:
2592 
     - bannerName
9155 kshitij.so 2593 
     - bannerType
8579 kshitij.so 2594 
    """
9155 kshitij.so 2595 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2596 
    return self.recv_getUriMapping()
2597 
 
9155 kshitij.so 2598 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2599 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2600 
    args = getUriMapping_args()
2601 
    args.bannerName = bannerName
9155 kshitij.so 2602 
    args.bannerType = bannerType
8579 kshitij.so 2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
2607 
  def recv_getUriMapping(self, ):
2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
2614 
    result = getUriMapping_result()
2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
2617 
    if result.success is not None:
2618 
      return result.success
2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2620 
 
2621 
  def addCampaign(self, campaign):
2622 
    """
2623 
    Parameters:
2624 
     - campaign
2625 
    """
2626 
    self.send_addCampaign(campaign)
2627 
    self.recv_addCampaign()
2628 
 
2629 
  def send_addCampaign(self, campaign):
2630 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2631 
    args = addCampaign_args()
2632 
    args.campaign = campaign
2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
2637 
  def recv_addCampaign(self, ):
2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
2644 
    result = addCampaign_result()
2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
2647 
    return
2648 
 
2649 
  def getCampaigns(self, campaignName):
2650 
    """
2651 
    Parameters:
2652 
     - campaignName
2653 
    """
2654 
    self.send_getCampaigns(campaignName)
2655 
    return self.recv_getCampaigns()
2656 
 
2657 
  def send_getCampaigns(self, campaignName):
2658 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2659 
    args = getCampaigns_args()
2660 
    args.campaignName = campaignName
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_getCampaigns(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = getCampaigns_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
2675 
    if result.success is not None:
2676 
      return result.success
2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2678 
 
2679 
  def deleteCampaign(self, campaignId):
2680 
    """
2681 
    Parameters:
2682 
     - campaignId
2683 
    """
2684 
    self.send_deleteCampaign(campaignId)
2685 
    self.recv_deleteCampaign()
2686 
 
2687 
  def send_deleteCampaign(self, campaignId):
2688 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2689 
    args = deleteCampaign_args()
2690 
    args.campaignId = campaignId
2691 
    args.write(self._oprot)
2692 
    self._oprot.writeMessageEnd()
2693 
    self._oprot.trans.flush()
2694 
 
2695 
  def recv_deleteCampaign(self, ):
2696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2697 
    if mtype == TMessageType.EXCEPTION:
2698 
      x = TApplicationException()
2699 
      x.read(self._iprot)
2700 
      self._iprot.readMessageEnd()
2701 
      raise x
2702 
    result = deleteCampaign_result()
2703 
    result.read(self._iprot)
2704 
    self._iprot.readMessageEnd()
2705 
    return
2706 
 
2707 
  def getAllCampaigns(self, ):
2708 
    self.send_getAllCampaigns()
2709 
    return self.recv_getAllCampaigns()
2710 
 
2711 
  def send_getAllCampaigns(self, ):
2712 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2713 
    args = getAllCampaigns_args()
2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2718 
  def recv_getAllCampaigns(self, ):
2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2725 
    result = getAllCampaigns_result()
2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success is not None:
2729 
      return result.success
2730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2731 
 
9155 kshitij.so 2732 
  def getActiveBannersForMobileSite(self, ):
2733 
    self.send_getActiveBannersForMobileSite()
2734 
    return self.recv_getActiveBannersForMobileSite()
2735 
 
2736 
  def send_getActiveBannersForMobileSite(self, ):
2737 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2738 
    args = getActiveBannersForMobileSite_args()
2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
2743 
  def recv_getActiveBannersForMobileSite(self, ):
2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
2750 
    result = getActiveBannersForMobileSite_result()
2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
2753 
    if result.success is not None:
2754 
      return result.success
2755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2756 
 
5944 mandeep.dh 2757 
  def deleteSimilarItem(self, itemId, catalogItemId):
2758 
    """
2759 
    Delete similar item.
2760 
 
2761 
    Parameters:
2762 
     - itemId
2763 
     - catalogItemId
2764 
    """
2765 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2766 
    return self.recv_deleteSimilarItem()
2767 
 
2768 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2769 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2770 
    args = deleteSimilarItem_args()
2771 
    args.itemId = itemId
2772 
    args.catalogItemId = catalogItemId
2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2777 
  def recv_deleteSimilarItem(self, ):
2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2784 
    result = deleteSimilarItem_result()
2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
2787 
    if result.success is not None:
2788 
      return result.success
2789 
    if result.cex is not None:
2790 
      raise result.cex
2791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2792 
 
2793 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2794 
    """
2795 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2796 
    If yes, returns the itemId else returns 0
2797 
 
2798 
    Parameters:
2799 
     - brand
2800 
     - modelNumber
2801 
     - modelName
2802 
     - color
2803 
    """
2804 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2805 
    return self.recv_checkSimilarItem()
2806 
 
2807 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2808 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2809 
    args = checkSimilarItem_args()
2810 
    args.brand = brand
2811 
    args.modelNumber = modelNumber
2812 
    args.modelName = modelName
2813 
    args.color = color
2814 
    args.write(self._oprot)
2815 
    self._oprot.writeMessageEnd()
2816 
    self._oprot.trans.flush()
2817 
 
2818 
  def recv_checkSimilarItem(self, ):
2819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2820 
    if mtype == TMessageType.EXCEPTION:
2821 
      x = TApplicationException()
2822 
      x.read(self._iprot)
2823 
      self._iprot.readMessageEnd()
2824 
      raise x
2825 
    result = checkSimilarItem_result()
2826 
    result.read(self._iprot)
2827 
    self._iprot.readMessageEnd()
2828 
    if result.success is not None:
2829 
      return result.success
2830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2831 
 
2832 
  def validateRiskyStatus(self, itemId):
2833 
    """
2834 
    Check wether item is risky and change status if inventory is not available for risky items
2835 
 
2836 
    Parameters:
2837 
     - itemId
2838 
    """
2839 
    self.send_validateRiskyStatus(itemId)
2840 
    self.recv_validateRiskyStatus()
2841 
 
2842 
  def send_validateRiskyStatus(self, itemId):
2843 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2844 
    args = validateRiskyStatus_args()
2845 
    args.itemId = itemId
2846 
    args.write(self._oprot)
2847 
    self._oprot.writeMessageEnd()
2848 
    self._oprot.trans.flush()
2849 
 
2850 
  def recv_validateRiskyStatus(self, ):
2851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2852 
    if mtype == TMessageType.EXCEPTION:
2853 
      x = TApplicationException()
2854 
      x.read(self._iprot)
2855 
      self._iprot.readMessageEnd()
2856 
      raise x
2857 
    result = validateRiskyStatus_result()
2858 
    result.read(self._iprot)
2859 
    self._iprot.readMessageEnd()
2860 
    return
2861 
 
2862 
  def changeItemRiskyFlag(self, itemId, risky):
2863 
    """
2864 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2865 
 
2866 
    Parameters:
2867 
     - itemId
2868 
     - risky
2869 
    """
2870 
    self.send_changeItemRiskyFlag(itemId, risky)
2871 
    self.recv_changeItemRiskyFlag()
2872 
 
2873 
  def send_changeItemRiskyFlag(self, itemId, risky):
2874 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2875 
    args = changeItemRiskyFlag_args()
2876 
    args.itemId = itemId
2877 
    args.risky = risky
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_changeItemRiskyFlag(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = changeItemRiskyFlag_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    return
2893 
 
2894 
  def getItemsByRiskyFlag(self, ):
2895 
    """
2896 
    Returns list of items marked as risky.
2897 
    """
2898 
    self.send_getItemsByRiskyFlag()
2899 
    return self.recv_getItemsByRiskyFlag()
2900 
 
2901 
  def send_getItemsByRiskyFlag(self, ):
2902 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2903 
    args = getItemsByRiskyFlag_args()
2904 
    args.write(self._oprot)
2905 
    self._oprot.writeMessageEnd()
2906 
    self._oprot.trans.flush()
2907 
 
2908 
  def recv_getItemsByRiskyFlag(self, ):
2909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2910 
    if mtype == TMessageType.EXCEPTION:
2911 
      x = TApplicationException()
2912 
      x.read(self._iprot)
2913 
      self._iprot.readMessageEnd()
2914 
      raise x
2915 
    result = getItemsByRiskyFlag_result()
2916 
    result.read(self._iprot)
2917 
    self._iprot.readMessageEnd()
2918 
    if result.success is not None:
2919 
      return result.success
2920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2921 
 
2922 
  def getItemsForMasterSheet(self, category, brand):
2923 
    """
2924 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2925 
 
2926 
    Parameters:
2927 
     - category
2928 
     - brand
2929 
    """
2930 
    self.send_getItemsForMasterSheet(category, brand)
2931 
    return self.recv_getItemsForMasterSheet()
2932 
 
2933 
  def send_getItemsForMasterSheet(self, category, brand):
2934 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2935 
    args = getItemsForMasterSheet_args()
2936 
    args.category = category
2937 
    args.brand = brand
2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
2942 
  def recv_getItemsForMasterSheet(self, ):
2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
2949 
    result = getItemsForMasterSheet_result()
2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
2952 
    if result.success is not None:
2953 
      return result.success
2954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2955 
 
2956 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2957 
    """
2958 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2959 
 
2960 
    Parameters:
2961 
     - beginIndex
2962 
     - totalItems
2963 
     - itemId
2964 
    """
2965 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2966 
    return self.recv_getSimilarItemsCatalogIds()
2967 
 
2968 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2969 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2970 
    args = getSimilarItemsCatalogIds_args()
2971 
    args.beginIndex = beginIndex
2972 
    args.totalItems = totalItems
2973 
    args.itemId = itemId
2974 
    args.write(self._oprot)
2975 
    self._oprot.writeMessageEnd()
2976 
    self._oprot.trans.flush()
2977 
 
2978 
  def recv_getSimilarItemsCatalogIds(self, ):
2979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2980 
    if mtype == TMessageType.EXCEPTION:
2981 
      x = TApplicationException()
2982 
      x.read(self._iprot)
2983 
      self._iprot.readMessageEnd()
2984 
      raise x
2985 
    result = getSimilarItemsCatalogIds_result()
2986 
    result.read(self._iprot)
2987 
    self._iprot.readMessageEnd()
2988 
    if result.success is not None:
2989 
      return result.success
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2991 
 
2992 
  def addProductNotification(self, itemId, email):
2993 
    """
2994 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2995 
 
2996 
    Parameters:
2997 
     - itemId
2998 
     - email
2999 
    """
3000 
    self.send_addProductNotification(itemId, email)
3001 
    return self.recv_addProductNotification()
3002 
 
3003 
  def send_addProductNotification(self, itemId, email):
3004 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3005 
    args = addProductNotification_args()
3006 
    args.itemId = itemId
3007 
    args.email = email
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3012 
  def recv_addProductNotification(self, ):
3013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3014 
    if mtype == TMessageType.EXCEPTION:
3015 
      x = TApplicationException()
3016 
      x.read(self._iprot)
3017 
      self._iprot.readMessageEnd()
3018 
      raise x
3019 
    result = addProductNotification_result()
3020 
    result.read(self._iprot)
3021 
    self._iprot.readMessageEnd()
3022 
    if result.success is not None:
3023 
      return result.success
3024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3025 
 
3026 
  def sendProductNotifications(self, ):
3027 
    """
3028 
    Send the product notifications to the users for items which has stock.
3029 
    """
3030 
    self.send_sendProductNotifications()
3031 
    return self.recv_sendProductNotifications()
3032 
 
3033 
  def send_sendProductNotifications(self, ):
3034 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3035 
    args = sendProductNotifications_args()
3036 
    args.write(self._oprot)
3037 
    self._oprot.writeMessageEnd()
3038 
    self._oprot.trans.flush()
3039 
 
3040 
  def recv_sendProductNotifications(self, ):
3041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3042 
    if mtype == TMessageType.EXCEPTION:
3043 
      x = TApplicationException()
3044 
      x.read(self._iprot)
3045 
      self._iprot.readMessageEnd()
3046 
      raise x
3047 
    result = sendProductNotifications_result()
3048 
    result.read(self._iprot)
3049 
    self._iprot.readMessageEnd()
3050 
    if result.success is not None:
3051 
      return result.success
3052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3053 
 
3054 
  def getAllBrandsByCategory(self, categoryId):
3055 
    """
3056 
    Returns list of brand names for a given category Id
3057 
 
3058 
    Parameters:
3059 
     - categoryId
3060 
    """
3061 
    self.send_getAllBrandsByCategory(categoryId)
3062 
    return self.recv_getAllBrandsByCategory()
3063 
 
3064 
  def send_getAllBrandsByCategory(self, categoryId):
3065 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3066 
    args = getAllBrandsByCategory_args()
3067 
    args.categoryId = categoryId
3068 
    args.write(self._oprot)
3069 
    self._oprot.writeMessageEnd()
3070 
    self._oprot.trans.flush()
3071 
 
3072 
  def recv_getAllBrandsByCategory(self, ):
3073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3074 
    if mtype == TMessageType.EXCEPTION:
3075 
      x = TApplicationException()
3076 
      x.read(self._iprot)
3077 
      self._iprot.readMessageEnd()
3078 
      raise x
3079 
    result = getAllBrandsByCategory_result()
3080 
    result.read(self._iprot)
3081 
    self._iprot.readMessageEnd()
3082 
    if result.success is not None:
3083 
      return result.success
3084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3085 
 
3086 
  def getAllBrands(self, ):
3087 
    """
3088 
    Returns list of brand names
3089 
    """
3090 
    self.send_getAllBrands()
3091 
    return self.recv_getAllBrands()
3092 
 
3093 
  def send_getAllBrands(self, ):
3094 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3095 
    args = getAllBrands_args()
3096 
    args.write(self._oprot)
3097 
    self._oprot.writeMessageEnd()
3098 
    self._oprot.trans.flush()
3099 
 
3100 
  def recv_getAllBrands(self, ):
3101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3102 
    if mtype == TMessageType.EXCEPTION:
3103 
      x = TApplicationException()
3104 
      x.read(self._iprot)
3105 
      self._iprot.readMessageEnd()
3106 
      raise x
3107 
    result = getAllBrands_result()
3108 
    result.read(self._iprot)
3109 
    self._iprot.readMessageEnd()
3110 
    if result.success is not None:
3111 
      return result.success
3112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3113 
 
3114 
  def getAllSources(self, ):
3115 
    """
3116 
    Return list of all sources
3117 
    """
3118 
    self.send_getAllSources()
3119 
    return self.recv_getAllSources()
3120 
 
3121 
  def send_getAllSources(self, ):
3122 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3123 
    args = getAllSources_args()
3124 
    args.write(self._oprot)
3125 
    self._oprot.writeMessageEnd()
3126 
    self._oprot.trans.flush()
3127 
 
3128 
  def recv_getAllSources(self, ):
3129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3130 
    if mtype == TMessageType.EXCEPTION:
3131 
      x = TApplicationException()
3132 
      x.read(self._iprot)
3133 
      self._iprot.readMessageEnd()
3134 
      raise x
3135 
    result = getAllSources_result()
3136 
    result.read(self._iprot)
3137 
    self._iprot.readMessageEnd()
3138 
    if result.success is not None:
3139 
      return result.success
3140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3141 
 
3142 
  def getItemPricingBySource(self, itemId, sourceId):
3143 
    """
3144 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3145 
 
3146 
    Parameters:
3147 
     - itemId
3148 
     - sourceId
3149 
    """
3150 
    self.send_getItemPricingBySource(itemId, sourceId)
3151 
    return self.recv_getItemPricingBySource()
3152 
 
3153 
  def send_getItemPricingBySource(self, itemId, sourceId):
3154 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3155 
    args = getItemPricingBySource_args()
3156 
    args.itemId = itemId
3157 
    args.sourceId = sourceId
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_getItemPricingBySource(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = getItemPricingBySource_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3172 
    if result.success is not None:
3173 
      return result.success
3174 
    if result.cex is not None:
3175 
      raise result.cex
3176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3177 
 
3178 
  def addSourceItemPricing(self, sourceItemPricing):
3179 
    """
3180 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3181 
    If item is not found or source is not found, it will throw exception.
3182 
 
3183 
    Parameters:
3184 
     - sourceItemPricing
3185 
    """
3186 
    self.send_addSourceItemPricing(sourceItemPricing)
3187 
    self.recv_addSourceItemPricing()
3188 
 
3189 
  def send_addSourceItemPricing(self, sourceItemPricing):
3190 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3191 
    args = addSourceItemPricing_args()
3192 
    args.sourceItemPricing = sourceItemPricing
3193 
    args.write(self._oprot)
3194 
    self._oprot.writeMessageEnd()
3195 
    self._oprot.trans.flush()
3196 
 
3197 
  def recv_addSourceItemPricing(self, ):
3198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3199 
    if mtype == TMessageType.EXCEPTION:
3200 
      x = TApplicationException()
3201 
      x.read(self._iprot)
3202 
      self._iprot.readMessageEnd()
3203 
      raise x
3204 
    result = addSourceItemPricing_result()
3205 
    result.read(self._iprot)
3206 
    self._iprot.readMessageEnd()
3207 
    if result.cex is not None:
3208 
      raise result.cex
3209 
    return
3210 
 
3211 
  def getAllSourcePricing(self, itemId):
3212 
    """
3213 
    Returns the list of source pricing information of an item.
3214 
    Raises an exception if item not found corresponding to itemId
3215 
 
3216 
    Parameters:
3217 
     - itemId
3218 
    """
3219 
    self.send_getAllSourcePricing(itemId)
3220 
    return self.recv_getAllSourcePricing()
3221 
 
3222 
  def send_getAllSourcePricing(self, itemId):
3223 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3224 
    args = getAllSourcePricing_args()
3225 
    args.itemId = itemId
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_getAllSourcePricing(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = getAllSourcePricing_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.success is not None:
3241 
      return result.success
3242 
    if result.cex is not None:
3243 
      raise result.cex
3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3245 
 
3246 
  def getItemForSource(self, item_id, sourceId):
3247 
    """
3248 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3249 
 
3250 
    Parameters:
3251 
     - item_id
3252 
     - sourceId
3253 
    """
3254 
    self.send_getItemForSource(item_id, sourceId)
3255 
    return self.recv_getItemForSource()
3256 
 
3257 
  def send_getItemForSource(self, item_id, sourceId):
3258 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3259 
    args = getItemForSource_args()
3260 
    args.item_id = item_id
3261 
    args.sourceId = sourceId
3262 
    args.write(self._oprot)
3263 
    self._oprot.writeMessageEnd()
3264 
    self._oprot.trans.flush()
3265 
 
3266 
  def recv_getItemForSource(self, ):
3267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3268 
    if mtype == TMessageType.EXCEPTION:
3269 
      x = TApplicationException()
3270 
      x.read(self._iprot)
3271 
      self._iprot.readMessageEnd()
3272 
      raise x
3273 
    result = getItemForSource_result()
3274 
    result.read(self._iprot)
3275 
    self._iprot.readMessageEnd()
3276 
    if result.success is not None:
3277 
      return result.success
3278 
    if result.cex is not None:
3279 
      raise result.cex
3280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3281 
 
3282 
  def searchItemsInRange(self, searchTerms, offset, limit):
3283 
    """
3284 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3285 
 
3286 
    Parameters:
3287 
     - searchTerms
3288 
     - offset
3289 
     - limit
3290 
    """
3291 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3292 
    return self.recv_searchItemsInRange()
3293 
 
3294 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3295 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3296 
    args = searchItemsInRange_args()
3297 
    args.searchTerms = searchTerms
3298 
    args.offset = offset
3299 
    args.limit = limit
3300 
    args.write(self._oprot)
3301 
    self._oprot.writeMessageEnd()
3302 
    self._oprot.trans.flush()
3303 
 
3304 
  def recv_searchItemsInRange(self, ):
3305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3306 
    if mtype == TMessageType.EXCEPTION:
3307 
      x = TApplicationException()
3308 
      x.read(self._iprot)
3309 
      self._iprot.readMessageEnd()
3310 
      raise x
3311 
    result = searchItemsInRange_result()
3312 
    result.read(self._iprot)
3313 
    self._iprot.readMessageEnd()
3314 
    if result.success is not None:
3315 
      return result.success
3316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3317 
 
3318 
  def getSearchResultCount(self, searchTerms):
3319 
    """
3320 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3321 
 
3322 
    Parameters:
3323 
     - searchTerms
3324 
    """
3325 
    self.send_getSearchResultCount(searchTerms)
3326 
    return self.recv_getSearchResultCount()
3327 
 
3328 
  def send_getSearchResultCount(self, searchTerms):
3329 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3330 
    args = getSearchResultCount_args()
3331 
    args.searchTerms = searchTerms
3332 
    args.write(self._oprot)
3333 
    self._oprot.writeMessageEnd()
3334 
    self._oprot.trans.flush()
3335 
 
3336 
  def recv_getSearchResultCount(self, ):
3337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3338 
    if mtype == TMessageType.EXCEPTION:
3339 
      x = TApplicationException()
3340 
      x.read(self._iprot)
3341 
      self._iprot.readMessageEnd()
3342 
      raise x
3343 
    result = getSearchResultCount_result()
3344 
    result.read(self._iprot)
3345 
    self._iprot.readMessageEnd()
3346 
    if result.success is not None:
3347 
      return result.success
3348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3349 
 
3350 
  def getProductNotifications(self, startDateTime):
3351 
    """
3352 
    Returns a list of product notifications added after a supplied datetime
3353 
 
3354 
    Parameters:
3355 
     - startDateTime
3356 
    """
3357 
    self.send_getProductNotifications(startDateTime)
3358 
    return self.recv_getProductNotifications()
3359 
 
3360 
  def send_getProductNotifications(self, startDateTime):
3361 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3362 
    args = getProductNotifications_args()
3363 
    args.startDateTime = startDateTime
3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_getProductNotifications(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = getProductNotifications_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3381 
 
7897 amar.kumar 3382 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3383 
    """
3384 
    Returns a list of count of requests for product notification against each item
3385 
 
3386 
    Parameters:
3387 
     - startDateTime
7897 amar.kumar 3388 
     - categoryId
5944 mandeep.dh 3389 
    """
7897 amar.kumar 3390 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3391 
    return self.recv_getProductNotificationRequestCount()
3392 
 
7897 amar.kumar 3393 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3394 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3395 
    args = getProductNotificationRequestCount_args()
3396 
    args.startDateTime = startDateTime
7897 amar.kumar 3397 
    args.categoryId = categoryId
5944 mandeep.dh 3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_getProductNotificationRequestCount(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = getProductNotificationRequestCount_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3412 
    if result.success is not None:
3413 
      return result.success
3414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3415 
 
3416 
  def addAuthorizationLog(self, itemId, username, reason):
3417 
    """
3418 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3419 
 
3420 
    Parameters:
3421 
     - itemId
3422 
     - username
3423 
     - reason
3424 
    """
3425 
    self.send_addAuthorizationLog(itemId, username, reason)
3426 
    return self.recv_addAuthorizationLog()
3427 
 
3428 
  def send_addAuthorizationLog(self, itemId, username, reason):
3429 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3430 
    args = addAuthorizationLog_args()
3431 
    args.itemId = itemId
3432 
    args.username = username
3433 
    args.reason = reason
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_addAuthorizationLog(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = addAuthorizationLog_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    if result.cex is not None:
3451 
      raise result.cex
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3453 
 
3454 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3455 
    """
3456 
    Parameters:
3457 
     - catalog_item_id
3458 
     - voucherType
3459 
     - voucherAmount
3460 
    """
3461 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3462 
    return self.recv_addupdateVoucherForItem()
3463 
 
3464 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3465 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3466 
    args = addupdateVoucherForItem_args()
3467 
    args.catalog_item_id = catalog_item_id
3468 
    args.voucherType = voucherType
3469 
    args.voucherAmount = voucherAmount
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_addupdateVoucherForItem(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = addupdateVoucherForItem_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3484 
    if result.success is not None:
3485 
      return result.success
3486 
    if result.cex is not None:
3487 
      raise result.cex
3488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3489 
 
3490 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3491 
    """
3492 
    Parameters:
3493 
     - catalog_item_id
3494 
     - voucherType
3495 
    """
3496 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3497 
    return self.recv_deleteVoucherForItem()
3498 
 
3499 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3500 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3501 
    args = deleteVoucherForItem_args()
3502 
    args.catalog_item_id = catalog_item_id
3503 
    args.voucherType = voucherType
3504 
    args.write(self._oprot)
3505 
    self._oprot.writeMessageEnd()
3506 
    self._oprot.trans.flush()
3507 
 
3508 
  def recv_deleteVoucherForItem(self, ):
3509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3510 
    if mtype == TMessageType.EXCEPTION:
3511 
      x = TApplicationException()
3512 
      x.read(self._iprot)
3513 
      self._iprot.readMessageEnd()
3514 
      raise x
3515 
    result = deleteVoucherForItem_result()
3516 
    result.read(self._iprot)
3517 
    self._iprot.readMessageEnd()
3518 
    if result.success is not None:
3519 
      return result.success
3520 
    if result.cex is not None:
3521 
      raise result.cex
3522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3523 
 
3524 
  def getVoucherAmount(self, itemId, voucherType):
3525 
    """
3526 
    Parameters:
3527 
     - itemId
3528 
     - voucherType
3529 
    """
3530 
    self.send_getVoucherAmount(itemId, voucherType)
3531 
    return self.recv_getVoucherAmount()
3532 
 
3533 
  def send_getVoucherAmount(self, itemId, voucherType):
3534 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3535 
    args = getVoucherAmount_args()
3536 
    args.itemId = itemId
3537 
    args.voucherType = voucherType
3538 
    args.write(self._oprot)
3539 
    self._oprot.writeMessageEnd()
3540 
    self._oprot.trans.flush()
3541 
 
3542 
  def recv_getVoucherAmount(self, ):
3543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3544 
    if mtype == TMessageType.EXCEPTION:
3545 
      x = TApplicationException()
3546 
      x.read(self._iprot)
3547 
      self._iprot.readMessageEnd()
3548 
      raise x
3549 
    result = getVoucherAmount_result()
3550 
    result.read(self._iprot)
3551 
    self._iprot.readMessageEnd()
3552 
    if result.success is not None:
3553 
      return result.success
3554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3555 
 
3556 
  def getAllItemVouchers(self, itemId):
3557 
    """
3558 
    Parameters:
3559 
     - itemId
3560 
    """
3561 
    self.send_getAllItemVouchers(itemId)
3562 
    return self.recv_getAllItemVouchers()
3563 
 
3564 
  def send_getAllItemVouchers(self, itemId):
3565 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3566 
    args = getAllItemVouchers_args()
3567 
    args.itemId = itemId
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_getAllItemVouchers(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = getAllItemVouchers_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3582 
    if result.success is not None:
3583 
      return result.success
3584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3585 
 
3586 
  def isValidCatalogItemId(self, catalog_item_id):
3587 
    """
3588 
    Parameters:
3589 
     - catalog_item_id
3590 
    """
3591 
    self.send_isValidCatalogItemId(catalog_item_id)
3592 
    return self.recv_isValidCatalogItemId()
3593 
 
3594 
  def send_isValidCatalogItemId(self, catalog_item_id):
3595 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3596 
    args = isValidCatalogItemId_args()
3597 
    args.catalog_item_id = catalog_item_id
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_isValidCatalogItemId(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = isValidCatalogItemId_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3615 
 
7330 amit.gupta 3616 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3617 
    """
3618 
    Parameters:
3619 
     - itemId
7330 amit.gupta 3620 
     - stateId
6039 amit.gupta 3621 
     - price
3622 
    """
7330 amit.gupta 3623 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3624 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3625 
 
7330 amit.gupta 3626 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3627 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3628 
    args = getVatPercentageForItem_args()
3629 
    args.itemId = itemId
7330 amit.gupta 3630 
    args.stateId = stateId
6039 amit.gupta 3631 
    args.price = price
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_getVatPercentageForItem(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = getVatPercentageForItem_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    if result.success is not None:
3647 
      return result.success
7340 amit.gupta 3648 
    if result.cex is not None:
3649 
      raise result.cex
6039 amit.gupta 3650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3651 
 
3652 
  def getVatAmountForItem(self, itemId, price):
3653 
    """
3654 
    Parameters:
3655 
     - itemId
3656 
     - price
3657 
    """
3658 
    self.send_getVatAmountForItem(itemId, price)
3659 
    return self.recv_getVatAmountForItem()
3660 
 
3661 
  def send_getVatAmountForItem(self, itemId, price):
3662 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3663 
    args = getVatAmountForItem_args()
3664 
    args.itemId = itemId
3665 
    args.price = price
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_getVatAmountForItem(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = getVatAmountForItem_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    if result.success is not None:
3681 
      return result.success
3682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3683 
 
6531 vikram.rag 3684 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3685 
    """
3686 
    Parameters:
3687 
     - offset
3688 
     - limit
3689 
    """
3690 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3691 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3692 
 
6531 vikram.rag 3693 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3694 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3695 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3696 
    args.offset = offset
3697 
    args.limit = limit
3698 
    args.write(self._oprot)
3699 
    self._oprot.writeMessageEnd()
3700 
    self._oprot.trans.flush()
3701 
 
3702 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3704 
    if mtype == TMessageType.EXCEPTION:
3705 
      x = TApplicationException()
3706 
      x.read(self._iprot)
3707 
      self._iprot.readMessageEnd()
3708 
      raise x
3709 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3710 
    result.read(self._iprot)
3711 
    self._iprot.readMessageEnd()
3712 
    if result.success is not None:
3713 
      return result.success
3714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3715 
 
6821 amar.kumar 3716 
  def getAllAliveItems(self, ):
3717 
    self.send_getAllAliveItems()
3718 
    return self.recv_getAllAliveItems()
3719 
 
3720 
  def send_getAllAliveItems(self, ):
3721 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3722 
    args = getAllAliveItems_args()
3723 
    args.write(self._oprot)
3724 
    self._oprot.writeMessageEnd()
3725 
    self._oprot.trans.flush()
3726 
 
3727 
  def recv_getAllAliveItems(self, ):
3728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3729 
    if mtype == TMessageType.EXCEPTION:
3730 
      x = TApplicationException()
3731 
      x.read(self._iprot)
3732 
      self._iprot.readMessageEnd()
3733 
      raise x
3734 
    result = getAllAliveItems_result()
3735 
    result.read(self._iprot)
3736 
    self._iprot.readMessageEnd()
3737 
    if result.success is not None:
3738 
      return result.success
3739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3740 
 
6921 anupam.sin 3741 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3742 
    """
3743 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3744 
 
6805 anupam.sin 3745 
    Parameters:
3746 
     - itemId
6921 anupam.sin 3747 
     - price
6805 anupam.sin 3748 
     - insurerId
3749 
     - quantity
3750 
    """
6921 anupam.sin 3751 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3752 
    return self.recv_getInsuranceAmount()
3753 
 
6921 anupam.sin 3754 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3755 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3756 
    args = getInsuranceAmount_args()
3757 
    args.itemId = itemId
6921 anupam.sin 3758 
    args.price = price
6805 anupam.sin 3759 
    args.insurerId = insurerId
3760 
    args.quantity = quantity
3761 
    args.write(self._oprot)
3762 
    self._oprot.writeMessageEnd()
3763 
    self._oprot.trans.flush()
3764 
 
3765 
  def recv_getInsuranceAmount(self, ):
3766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3767 
    if mtype == TMessageType.EXCEPTION:
3768 
      x = TApplicationException()
3769 
      x.read(self._iprot)
3770 
      self._iprot.readMessageEnd()
3771 
      raise x
3772 
    result = getInsuranceAmount_result()
3773 
    result.read(self._iprot)
3774 
    self._iprot.readMessageEnd()
3775 
    if result.success is not None:
3776 
      return result.success
3777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3778 
 
3779 
  def getInsurer(self, insurerId):
3780 
    """
3781 
    Parameters:
3782 
     - insurerId
3783 
    """
3784 
    self.send_getInsurer(insurerId)
3785 
    return self.recv_getInsurer()
3786 
 
3787 
  def send_getInsurer(self, insurerId):
3788 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3789 
    args = getInsurer_args()
3790 
    args.insurerId = insurerId
3791 
    args.write(self._oprot)
3792 
    self._oprot.writeMessageEnd()
3793 
    self._oprot.trans.flush()
3794 
 
3795 
  def recv_getInsurer(self, ):
3796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3797 
    if mtype == TMessageType.EXCEPTION:
3798 
      x = TApplicationException()
3799 
      x.read(self._iprot)
3800 
      self._iprot.readMessageEnd()
3801 
      raise x
3802 
    result = getInsurer_result()
3803 
    result.read(self._iprot)
3804 
    self._iprot.readMessageEnd()
3805 
    if result.success is not None:
3806 
      return result.success
3807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3808 
 
6838 vikram.rag 3809 
  def getAllInsurers(self, ):
3810 
    self.send_getAllInsurers()
3811 
    return self.recv_getAllInsurers()
6805 anupam.sin 3812 
 
6838 vikram.rag 3813 
  def send_getAllInsurers(self, ):
3814 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3815 
    args = getAllInsurers_args()
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_getAllInsurers(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = getAllInsurers_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3830 
    if result.success is not None:
3831 
      return result.success
3832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3833 
 
6962 rajveer 3834 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3835 
    """
3836 
    Parameters:
3837 
     - insurerId
3838 
     - amount
3839 
    """
3840 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3841 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3842 
 
6962 rajveer 3843 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3844 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3845 
    args = updateInsuranceDeclaredAmount_args()
3846 
    args.insurerId = insurerId
3847 
    args.amount = amount
3848 
    args.write(self._oprot)
3849 
    self._oprot.writeMessageEnd()
3850 
    self._oprot.trans.flush()
3851 
 
3852 
  def recv_updateInsuranceDeclaredAmount(self, ):
3853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3854 
    if mtype == TMessageType.EXCEPTION:
3855 
      x = TApplicationException()
3856 
      x.read(self._iprot)
3857 
      self._iprot.readMessageEnd()
3858 
      raise x
3859 
    result = updateInsuranceDeclaredAmount_result()
3860 
    result.read(self._iprot)
3861 
    self._iprot.readMessageEnd()
3862 
    return
3863 
 
7190 amar.kumar 3864 
  def getFreebieForItem(self, itemId):
3865 
    """
3866 
    Parameters:
3867 
     - itemId
3868 
    """
3869 
    self.send_getFreebieForItem(itemId)
3870 
    return self.recv_getFreebieForItem()
6962 rajveer 3871 
 
7190 amar.kumar 3872 
  def send_getFreebieForItem(self, itemId):
3873 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3874 
    args = getFreebieForItem_args()
3875 
    args.itemId = itemId
3876 
    args.write(self._oprot)
3877 
    self._oprot.writeMessageEnd()
3878 
    self._oprot.trans.flush()
3879 
 
3880 
  def recv_getFreebieForItem(self, ):
3881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3882 
    if mtype == TMessageType.EXCEPTION:
3883 
      x = TApplicationException()
3884 
      x.read(self._iprot)
3885 
      self._iprot.readMessageEnd()
3886 
      raise x
3887 
    result = getFreebieForItem_result()
3888 
    result.read(self._iprot)
3889 
    self._iprot.readMessageEnd()
3890 
    if result.success is not None:
3891 
      return result.success
3892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3893 
 
3894 
  def addOrUpdateFreebieForItem(self, freebieItem):
3895 
    """
3896 
    Parameters:
3897 
     - freebieItem
3898 
    """
3899 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3900 
    self.recv_addOrUpdateFreebieForItem()
3901 
 
3902 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3903 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3904 
    args = addOrUpdateFreebieForItem_args()
3905 
    args.freebieItem = freebieItem
3906 
    args.write(self._oprot)
3907 
    self._oprot.writeMessageEnd()
3908 
    self._oprot.trans.flush()
3909 
 
3910 
  def recv_addOrUpdateFreebieForItem(self, ):
3911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3912 
    if mtype == TMessageType.EXCEPTION:
3913 
      x = TApplicationException()
3914 
      x.read(self._iprot)
3915 
      self._iprot.readMessageEnd()
3916 
      raise x
3917 
    result = addOrUpdateFreebieForItem_result()
3918 
    result.read(self._iprot)
3919 
    self._iprot.readMessageEnd()
3920 
    return
3921 
 
7272 amit.gupta 3922 
  def addOrUpdateBrandInfo(self, brandInfo):
3923 
    """
3924 
    Parameters:
3925 
     - brandInfo
3926 
    """
3927 
    self.send_addOrUpdateBrandInfo(brandInfo)
3928 
    self.recv_addOrUpdateBrandInfo()
3929 
 
3930 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3931 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3932 
    args = addOrUpdateBrandInfo_args()
3933 
    args.brandInfo = brandInfo
3934 
    args.write(self._oprot)
3935 
    self._oprot.writeMessageEnd()
3936 
    self._oprot.trans.flush()
3937 
 
3938 
  def recv_addOrUpdateBrandInfo(self, ):
3939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3940 
    if mtype == TMessageType.EXCEPTION:
3941 
      x = TApplicationException()
3942 
      x.read(self._iprot)
3943 
      self._iprot.readMessageEnd()
3944 
      raise x
3945 
    result = addOrUpdateBrandInfo_result()
3946 
    result.read(self._iprot)
3947 
    self._iprot.readMessageEnd()
3948 
    return
3949 
 
3950 
  def getBrandInfo(self, ):
3951 
    self.send_getBrandInfo()
3952 
    return self.recv_getBrandInfo()
3953 
 
3954 
  def send_getBrandInfo(self, ):
3955 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3956 
    args = getBrandInfo_args()
3957 
    args.write(self._oprot)
3958 
    self._oprot.writeMessageEnd()
3959 
    self._oprot.trans.flush()
3960 
 
3961 
  def recv_getBrandInfo(self, ):
3962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3963 
    if mtype == TMessageType.EXCEPTION:
3964 
      x = TApplicationException()
3965 
      x.read(self._iprot)
3966 
      self._iprot.readMessageEnd()
3967 
      raise x
3968 
    result = getBrandInfo_result()
3969 
    result.read(self._iprot)
3970 
    self._iprot.readMessageEnd()
3971 
    if result.success is not None:
3972 
      return result.success
3973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3974 
 
7256 rajveer 3975 
  def getStorePricing(self, itemId):
3976 
    """
3977 
    Parameters:
3978 
     - itemId
3979 
    """
3980 
    self.send_getStorePricing(itemId)
3981 
    return self.recv_getStorePricing()
7190 amar.kumar 3982 
 
7256 rajveer 3983 
  def send_getStorePricing(self, itemId):
3984 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3985 
    args = getStorePricing_args()
3986 
    args.itemId = itemId
3987 
    args.write(self._oprot)
3988 
    self._oprot.writeMessageEnd()
3989 
    self._oprot.trans.flush()
3990 
 
3991 
  def recv_getStorePricing(self, ):
3992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3993 
    if mtype == TMessageType.EXCEPTION:
3994 
      x = TApplicationException()
3995 
      x.read(self._iprot)
3996 
      self._iprot.readMessageEnd()
3997 
      raise x
3998 
    result = getStorePricing_result()
3999 
    result.read(self._iprot)
4000 
    self._iprot.readMessageEnd()
4001 
    if result.success is not None:
4002 
      return result.success
4003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4004 
 
7306 rajveer 4005 
  def getStorePricings(self, itemIds):
4006 
    """
4007 
    Parameters:
4008 
     - itemIds
4009 
    """
4010 
    self.send_getStorePricings(itemIds)
4011 
    return self.recv_getStorePricings()
4012 
 
4013 
  def send_getStorePricings(self, itemIds):
4014 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4015 
    args = getStorePricings_args()
4016 
    args.itemIds = itemIds
4017 
    args.write(self._oprot)
4018 
    self._oprot.writeMessageEnd()
4019 
    self._oprot.trans.flush()
4020 
 
4021 
  def recv_getStorePricings(self, ):
4022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4023 
    if mtype == TMessageType.EXCEPTION:
4024 
      x = TApplicationException()
4025 
      x.read(self._iprot)
4026 
      self._iprot.readMessageEnd()
4027 
      raise x
4028 
    result = getStorePricings_result()
4029 
    result.read(self._iprot)
4030 
    self._iprot.readMessageEnd()
4031 
    if result.success is not None:
4032 
      return result.success
4033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4034 
 
7382 rajveer 4035 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4036 
    """
4037 
    Parameters:
4038 
     - sp
7382 rajveer 4039 
     - allColors
7265 rajveer 4040 
    """
7382 rajveer 4041 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4042 
    self.recv_updateStorePricing()
7256 rajveer 4043 
 
7382 rajveer 4044 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4045 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4046 
    args = updateStorePricing_args()
4047 
    args.sp = sp
7382 rajveer 4048 
    args.allColors = allColors
7265 rajveer 4049 
    args.write(self._oprot)
4050 
    self._oprot.writeMessageEnd()
4051 
    self._oprot.trans.flush()
4052 
 
4053 
  def recv_updateStorePricing(self, ):
4054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4055 
    if mtype == TMessageType.EXCEPTION:
4056 
      x = TApplicationException()
4057 
      x.read(self._iprot)
4058 
      self._iprot.readMessageEnd()
4059 
      raise x
4060 
    result = updateStorePricing_result()
4061 
    result.read(self._iprot)
4062 
    self._iprot.readMessageEnd()
4063 
    return
4064 
 
7281 kshitij.so 4065 
  def getAllAmazonListedItems(self, ):
4066 
    self.send_getAllAmazonListedItems()
4067 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4068 
 
7281 kshitij.so 4069 
  def send_getAllAmazonListedItems(self, ):
4070 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4071 
    args = getAllAmazonListedItems_args()
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_getAllAmazonListedItems(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = getAllAmazonListedItems_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
4088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4089 
 
8619 kshitij.so 4090 
  def searchAmazonItems(self, searchTerm, offset, limit):
4091 
    """
4092 
    Parameters:
4093 
     - searchTerm
4094 
     - offset
4095 
     - limit
4096 
    """
4097 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4098 
    return self.recv_searchAmazonItems()
4099 
 
4100 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4101 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4102 
    args = searchAmazonItems_args()
4103 
    args.searchTerm = searchTerm
4104 
    args.offset = offset
4105 
    args.limit = limit
4106 
    args.write(self._oprot)
4107 
    self._oprot.writeMessageEnd()
4108 
    self._oprot.trans.flush()
4109 
 
4110 
  def recv_searchAmazonItems(self, ):
4111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4112 
    if mtype == TMessageType.EXCEPTION:
4113 
      x = TApplicationException()
4114 
      x.read(self._iprot)
4115 
      self._iprot.readMessageEnd()
4116 
      raise x
4117 
    result = searchAmazonItems_result()
4118 
    result.read(self._iprot)
4119 
    self._iprot.readMessageEnd()
4120 
    if result.success is not None:
4121 
      return result.success
4122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4123 
 
4124 
  def getAmazonSearchResultCount(self, searchTerm):
4125 
    """
4126 
    Parameters:
4127 
     - searchTerm
4128 
    """
4129 
    self.send_getAmazonSearchResultCount(searchTerm)
4130 
    return self.recv_getAmazonSearchResultCount()
4131 
 
4132 
  def send_getAmazonSearchResultCount(self, searchTerm):
4133 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4134 
    args = getAmazonSearchResultCount_args()
4135 
    args.searchTerm = searchTerm
4136 
    args.write(self._oprot)
4137 
    self._oprot.writeMessageEnd()
4138 
    self._oprot.trans.flush()
4139 
 
4140 
  def recv_getAmazonSearchResultCount(self, ):
4141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4142 
    if mtype == TMessageType.EXCEPTION:
4143 
      x = TApplicationException()
4144 
      x.read(self._iprot)
4145 
      self._iprot.readMessageEnd()
4146 
      raise x
4147 
    result = getAmazonSearchResultCount_result()
4148 
    result.read(self._iprot)
4149 
    self._iprot.readMessageEnd()
4150 
    if result.success is not None:
4151 
      return result.success
4152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4153 
 
4154 
  def getCountForAmazonlistedItems(self, ):
4155 
    self.send_getCountForAmazonlistedItems()
4156 
    return self.recv_getCountForAmazonlistedItems()
4157 
 
4158 
  def send_getCountForAmazonlistedItems(self, ):
4159 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4160 
    args = getCountForAmazonlistedItems_args()
4161 
    args.write(self._oprot)
4162 
    self._oprot.writeMessageEnd()
4163 
    self._oprot.trans.flush()
4164 
 
4165 
  def recv_getCountForAmazonlistedItems(self, ):
4166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4167 
    if mtype == TMessageType.EXCEPTION:
4168 
      x = TApplicationException()
4169 
      x.read(self._iprot)
4170 
      self._iprot.readMessageEnd()
4171 
      raise x
4172 
    result = getCountForAmazonlistedItems_result()
4173 
    result.read(self._iprot)
4174 
    self._iprot.readMessageEnd()
4175 
    if result.success is not None:
4176 
      return result.success
4177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4178 
 
7281 kshitij.so 4179 
  def getAmazonItemDetails(self, itemId):
4180 
    """
4181 
    Parameters:
4182 
     - itemId
4183 
    """
4184 
    self.send_getAmazonItemDetails(itemId)
4185 
    return self.recv_getAmazonItemDetails()
4186 
 
4187 
  def send_getAmazonItemDetails(self, itemId):
4188 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4189 
    args = getAmazonItemDetails_args()
4190 
    args.itemId = itemId
4191 
    args.write(self._oprot)
4192 
    self._oprot.writeMessageEnd()
4193 
    self._oprot.trans.flush()
4194 
 
4195 
  def recv_getAmazonItemDetails(self, ):
4196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4197 
    if mtype == TMessageType.EXCEPTION:
4198 
      x = TApplicationException()
4199 
      x.read(self._iprot)
4200 
      self._iprot.readMessageEnd()
4201 
      raise x
4202 
    result = getAmazonItemDetails_result()
4203 
    result.read(self._iprot)
4204 
    self._iprot.readMessageEnd()
4205 
    if result.success is not None:
4206 
      return result.success
4207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4208 
 
8168 kshitij.so 4209 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4210 
    """
4211 
    Parameters:
8168 kshitij.so 4212 
     - amazonlisted
7281 kshitij.so 4213 
    """
8168 kshitij.so 4214 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4215 
    self.recv_updateAmazonItemDetails()
4216 
 
8168 kshitij.so 4217 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4218 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4219 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4220 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4221 
    args.write(self._oprot)
4222 
    self._oprot.writeMessageEnd()
4223 
    self._oprot.trans.flush()
4224 
 
4225 
  def recv_updateAmazonItemDetails(self, ):
4226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4227 
    if mtype == TMessageType.EXCEPTION:
4228 
      x = TApplicationException()
4229 
      x.read(self._iprot)
4230 
      self._iprot.readMessageEnd()
4231 
      raise x
4232 
    result = updateAmazonItemDetails_result()
4233 
    result.read(self._iprot)
4234 
    self._iprot.readMessageEnd()
4235 
    return
4236 
 
4237 
  def addAmazonItem(self, amazonlisted):
4238 
    """
4239 
    Parameters:
4240 
     - amazonlisted
4241 
    """
4242 
    self.send_addAmazonItem(amazonlisted)
4243 
    self.recv_addAmazonItem()
4244 
 
4245 
  def send_addAmazonItem(self, amazonlisted):
4246 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4247 
    args = addAmazonItem_args()
4248 
    args.amazonlisted = amazonlisted
4249 
    args.write(self._oprot)
4250 
    self._oprot.writeMessageEnd()
4251 
    self._oprot.trans.flush()
4252 
 
4253 
  def recv_addAmazonItem(self, ):
4254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4255 
    if mtype == TMessageType.EXCEPTION:
4256 
      x = TApplicationException()
4257 
      x.read(self._iprot)
4258 
      self._iprot.readMessageEnd()
4259 
      raise x
4260 
    result = addAmazonItem_result()
4261 
    result.read(self._iprot)
4262 
    self._iprot.readMessageEnd()
4263 
    return
4264 
 
7291 vikram.rag 4265 
  def getAsinItems(self, ):
4266 
    self.send_getAsinItems()
4267 
    return self.recv_getAsinItems()
7281 kshitij.so 4268 
 
7291 vikram.rag 4269 
  def send_getAsinItems(self, ):
4270 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4271 
    args = getAsinItems_args()
4272 
    args.write(self._oprot)
4273 
    self._oprot.writeMessageEnd()
4274 
    self._oprot.trans.flush()
4275 
 
4276 
  def recv_getAsinItems(self, ):
4277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4278 
    if mtype == TMessageType.EXCEPTION:
4279 
      x = TApplicationException()
4280 
      x.read(self._iprot)
4281 
      self._iprot.readMessageEnd()
4282 
      raise x
4283 
    result = getAsinItems_result()
4284 
    result.read(self._iprot)
4285 
    self._iprot.readMessageEnd()
4286 
    if result.success is not None:
4287 
      return result.success
4288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4289 
 
4290 
  def getAllFbaListedItems(self, ):
4291 
    self.send_getAllFbaListedItems()
4292 
    return self.recv_getAllFbaListedItems()
4293 
 
4294 
  def send_getAllFbaListedItems(self, ):
4295 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4296 
    args = getAllFbaListedItems_args()
4297 
    args.write(self._oprot)
4298 
    self._oprot.writeMessageEnd()
4299 
    self._oprot.trans.flush()
4300 
 
4301 
  def recv_getAllFbaListedItems(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 = getAllFbaListedItems_result()
4309 
    result.read(self._iprot)
4310 
    self._iprot.readMessageEnd()
4311 
    if result.success is not None:
4312 
      return result.success
4313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4314 
 
4315 
  def getAllNonFbaListedItems(self, ):
4316 
    self.send_getAllNonFbaListedItems()
4317 
    return self.recv_getAllNonFbaListedItems()
4318 
 
4319 
  def send_getAllNonFbaListedItems(self, ):
4320 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4321 
    args = getAllNonFbaListedItems_args()
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_getAllNonFbaListedItems(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = getAllNonFbaListedItems_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4339 
 
7460 kshitij.so 4340 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4341 
    """
4342 
    Parameters:
4343 
     - itemId
4344 
     - holdInventory
4345 
     - defaultInventory
4346 
    """
4347 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4348 
    return self.recv_updateItemInventory()
7291 vikram.rag 4349 
 
7460 kshitij.so 4350 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4351 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4352 
    args = updateItemInventory_args()
4353 
    args.itemId = itemId
4354 
    args.holdInventory = holdInventory
4355 
    args.defaultInventory = defaultInventory
4356 
    args.write(self._oprot)
4357 
    self._oprot.writeMessageEnd()
4358 
    self._oprot.trans.flush()
4359 
 
4360 
  def recv_updateItemInventory(self, ):
4361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4362 
    if mtype == TMessageType.EXCEPTION:
4363 
      x = TApplicationException()
4364 
      x.read(self._iprot)
4365 
      self._iprot.readMessageEnd()
4366 
      raise x
4367 
    result = updateItemInventory_result()
4368 
    result.read(self._iprot)
4369 
    self._iprot.readMessageEnd()
4370 
    if result.success is not None:
4371 
      return result.success
4372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4373 
 
7770 kshitij.so 4374 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4375 
    """
4376 
    Parameters:
4377 
     - type
4378 
     - sku
4379 
     - timestamp
4380 
    """
4381 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4382 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4383 
 
7770 kshitij.so 4384 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4385 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4386 
    args = updateTimestampForAmazonFeeds_args()
4387 
    args.type = type
4388 
    args.sku = sku
4389 
    args.timestamp = timestamp
4390 
    args.write(self._oprot)
4391 
    self._oprot.writeMessageEnd()
4392 
    self._oprot.trans.flush()
4393 
 
4394 
  def recv_updateTimestampForAmazonFeeds(self, ):
4395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4396 
    if mtype == TMessageType.EXCEPTION:
4397 
      x = TApplicationException()
4398 
      x.read(self._iprot)
4399 
      self._iprot.readMessageEnd()
4400 
      raise x
4401 
    result = updateTimestampForAmazonFeeds_result()
4402 
    result.read(self._iprot)
4403 
    self._iprot.readMessageEnd()
4404 
    if result.success is not None:
4405 
      return result.success
4406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4407 
 
7897 amar.kumar 4408 
  def getAllParentCategories(self, ):
4409 
    self.send_getAllParentCategories()
4410 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4411 
 
7897 amar.kumar 4412 
  def send_getAllParentCategories(self, ):
4413 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4414 
    args = getAllParentCategories_args()
4415 
    args.write(self._oprot)
4416 
    self._oprot.writeMessageEnd()
4417 
    self._oprot.trans.flush()
4418 
 
4419 
  def recv_getAllParentCategories(self, ):
4420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4421 
    if mtype == TMessageType.EXCEPTION:
4422 
      x = TApplicationException()
4423 
      x.read(self._iprot)
4424 
      self._iprot.readMessageEnd()
4425 
      raise x
4426 
    result = getAllParentCategories_result()
4427 
    result.read(self._iprot)
4428 
    self._iprot.readMessageEnd()
4429 
    if result.success is not None:
4430 
      return result.success
4431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4432 
 
7977 kshitij.so 4433 
  def addPageViewEvent(self, pageViewEvents):
4434 
    """
4435 
    Parameters:
4436 
     - pageViewEvents
4437 
    """
4438 
    self.send_addPageViewEvent(pageViewEvents)
4439 
    self.recv_addPageViewEvent()
7897 amar.kumar 4440 
 
7977 kshitij.so 4441 
  def send_addPageViewEvent(self, pageViewEvents):
4442 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4443 
    args = addPageViewEvent_args()
4444 
    args.pageViewEvents = pageViewEvents
4445 
    args.write(self._oprot)
4446 
    self._oprot.writeMessageEnd()
4447 
    self._oprot.trans.flush()
4448 
 
4449 
  def recv_addPageViewEvent(self, ):
4450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4451 
    if mtype == TMessageType.EXCEPTION:
4452 
      x = TApplicationException()
4453 
      x.read(self._iprot)
4454 
      self._iprot.readMessageEnd()
4455 
      raise x
4456 
    result = addPageViewEvent_result()
4457 
    result.read(self._iprot)
4458 
    self._iprot.readMessageEnd()
4459 
    return
4460 
 
4461 
  def addCartEvent(self, cartEvents):
4462 
    """
4463 
    Parameters:
4464 
     - cartEvents
4465 
    """
4466 
    self.send_addCartEvent(cartEvents)
4467 
    self.recv_addCartEvent()
4468 
 
4469 
  def send_addCartEvent(self, cartEvents):
4470 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4471 
    args = addCartEvent_args()
4472 
    args.cartEvents = cartEvents
4473 
    args.write(self._oprot)
4474 
    self._oprot.writeMessageEnd()
4475 
    self._oprot.trans.flush()
4476 
 
4477 
  def recv_addCartEvent(self, ):
4478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4479 
    if mtype == TMessageType.EXCEPTION:
4480 
      x = TApplicationException()
4481 
      x.read(self._iprot)
4482 
      self._iprot.readMessageEnd()
4483 
      raise x
4484 
    result = addCartEvent_result()
4485 
    result.read(self._iprot)
4486 
    self._iprot.readMessageEnd()
4487 
    return
4488 
 
8182 amar.kumar 4489 
  def addEbayItem(self, ebayItem):
4490 
    """
4491 
    Parameters:
4492 
     - ebayItem
4493 
    """
4494 
    self.send_addEbayItem(ebayItem)
4495 
    self.recv_addEbayItem()
4496 
 
4497 
  def send_addEbayItem(self, ebayItem):
4498 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4499 
    args = addEbayItem_args()
4500 
    args.ebayItem = ebayItem
4501 
    args.write(self._oprot)
4502 
    self._oprot.writeMessageEnd()
4503 
    self._oprot.trans.flush()
4504 
 
4505 
  def recv_addEbayItem(self, ):
4506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4507 
    if mtype == TMessageType.EXCEPTION:
4508 
      x = TApplicationException()
4509 
      x.read(self._iprot)
4510 
      self._iprot.readMessageEnd()
4511 
      raise x
4512 
    result = addEbayItem_result()
4513 
    result.read(self._iprot)
4514 
    self._iprot.readMessageEnd()
4515 
    return
4516 
 
4517 
  def getEbayItem(self, listingId):
4518 
    """
4519 
    Parameters:
4520 
     - listingId
4521 
    """
4522 
    self.send_getEbayItem(listingId)
4523 
    return self.recv_getEbayItem()
4524 
 
4525 
  def send_getEbayItem(self, listingId):
4526 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4527 
    args = getEbayItem_args()
4528 
    args.listingId = listingId
4529 
    args.write(self._oprot)
4530 
    self._oprot.writeMessageEnd()
4531 
    self._oprot.trans.flush()
4532 
 
4533 
  def recv_getEbayItem(self, ):
4534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4535 
    if mtype == TMessageType.EXCEPTION:
4536 
      x = TApplicationException()
4537 
      x.read(self._iprot)
4538 
      self._iprot.readMessageEnd()
4539 
      raise x
4540 
    result = getEbayItem_result()
4541 
    result.read(self._iprot)
4542 
    self._iprot.readMessageEnd()
4543 
    if result.success is not None:
4544 
      return result.success
4545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4546 
 
4547 
  def updateEbayItem(self, ebayItem):
4548 
    """
4549 
    Parameters:
4550 
     - ebayItem
4551 
    """
4552 
    self.send_updateEbayItem(ebayItem)
4553 
    self.recv_updateEbayItem()
4554 
 
4555 
  def send_updateEbayItem(self, ebayItem):
4556 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4557 
    args = updateEbayItem_args()
4558 
    args.ebayItem = ebayItem
4559 
    args.write(self._oprot)
4560 
    self._oprot.writeMessageEnd()
4561 
    self._oprot.trans.flush()
4562 
 
4563 
  def recv_updateEbayItem(self, ):
4564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4565 
    if mtype == TMessageType.EXCEPTION:
4566 
      x = TApplicationException()
4567 
      x.read(self._iprot)
4568 
      self._iprot.readMessageEnd()
4569 
      raise x
4570 
    result = updateEbayItem_result()
4571 
    result.read(self._iprot)
4572 
    self._iprot.readMessageEnd()
4573 
    return
4574 
 
8139 kshitij.so 4575 
  def getAmazonListedItems(self, offset, limit):
4576 
    """
4577 
    Parameters:
4578 
     - offset
4579 
     - limit
4580 
    """
4581 
    self.send_getAmazonListedItems(offset, limit)
4582 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4583 
 
8139 kshitij.so 4584 
  def send_getAmazonListedItems(self, offset, limit):
4585 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4586 
    args = getAmazonListedItems_args()
4587 
    args.offset = offset
4588 
    args.limit = limit
4589 
    args.write(self._oprot)
4590 
    self._oprot.writeMessageEnd()
4591 
    self._oprot.trans.flush()
4592 
 
4593 
  def recv_getAmazonListedItems(self, ):
4594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4595 
    if mtype == TMessageType.EXCEPTION:
4596 
      x = TApplicationException()
4597 
      x.read(self._iprot)
4598 
      self._iprot.readMessageEnd()
4599 
      raise x
4600 
    result = getAmazonListedItems_result()
4601 
    result.read(self._iprot)
4602 
    self._iprot.readMessageEnd()
4603 
    if result.success is not None:
4604 
      return result.success
4605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4606 
 
8168 kshitij.so 4607 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4608 
    """
4609 
    Parameters:
4610 
     - amazonlisted
4611 
    """
4612 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4613 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4614 
 
8168 kshitij.so 4615 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4616 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4617 
    args = updateAmazonAttributesInBulk_args()
4618 
    args.amazonlisted = amazonlisted
4619 
    args.write(self._oprot)
4620 
    self._oprot.writeMessageEnd()
4621 
    self._oprot.trans.flush()
4622 
 
4623 
  def recv_updateAmazonAttributesInBulk(self, ):
4624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4625 
    if mtype == TMessageType.EXCEPTION:
4626 
      x = TApplicationException()
4627 
      x.read(self._iprot)
4628 
      self._iprot.readMessageEnd()
4629 
      raise x
4630 
    result = updateAmazonAttributesInBulk_result()
4631 
    result.read(self._iprot)
4632 
    self._iprot.readMessageEnd()
4633 
    if result.success is not None:
4634 
      return result.success
4635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4636 
 
8379 vikram.rag 4637 
  def getAllItemstoListOnFba(self, ):
4638 
    self.send_getAllItemstoListOnFba()
4639 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4640 
 
8379 vikram.rag 4641 
  def send_getAllItemstoListOnFba(self, ):
4642 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4643 
    args = getAllItemstoListOnFba_args()
4644 
    args.write(self._oprot)
4645 
    self._oprot.writeMessageEnd()
4646 
    self._oprot.trans.flush()
4647 
 
4648 
  def recv_getAllItemstoListOnFba(self, ):
4649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4650 
    if mtype == TMessageType.EXCEPTION:
4651 
      x = TApplicationException()
4652 
      x.read(self._iprot)
4653 
      self._iprot.readMessageEnd()
4654 
      raise x
4655 
    result = getAllItemstoListOnFba_result()
4656 
    result.read(self._iprot)
4657 
    self._iprot.readMessageEnd()
4658 
    if result.success is not None:
4659 
      return result.success
4660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4661 
 
4662 
  def getAllItemstoListOnNonFba(self, ):
4663 
    self.send_getAllItemstoListOnNonFba()
4664 
    return self.recv_getAllItemstoListOnNonFba()
4665 
 
4666 
  def send_getAllItemstoListOnNonFba(self, ):
4667 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4668 
    args = getAllItemstoListOnNonFba_args()
4669 
    args.write(self._oprot)
4670 
    self._oprot.writeMessageEnd()
4671 
    self._oprot.trans.flush()
4672 
 
4673 
  def recv_getAllItemstoListOnNonFba(self, ):
4674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4675 
    if mtype == TMessageType.EXCEPTION:
4676 
      x = TApplicationException()
4677 
      x.read(self._iprot)
4678 
      self._iprot.readMessageEnd()
4679 
      raise x
4680 
    result = getAllItemstoListOnNonFba_result()
4681 
    result.read(self._iprot)
4682 
    self._iprot.readMessageEnd()
4683 
    if result.success is not None:
4684 
      return result.success
4685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4686 
 
8619 kshitij.so 4687 
  def updateAsin(self, item):
4688 
    """
4689 
    Parameters:
4690 
     - item
4691 
    """
4692 
    self.send_updateAsin(item)
4693 
    self.recv_updateAsin()
8616 vikram.rag 4694 
 
8619 kshitij.so 4695 
  def send_updateAsin(self, item):
4696 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4697 
    args = updateAsin_args()
4698 
    args.item = item
4699 
    args.write(self._oprot)
4700 
    self._oprot.writeMessageEnd()
4701 
    self._oprot.trans.flush()
4702 
 
4703 
  def recv_updateAsin(self, ):
4704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4705 
    if mtype == TMessageType.EXCEPTION:
4706 
      x = TApplicationException()
4707 
      x.read(self._iprot)
4708 
      self._iprot.readMessageEnd()
4709 
      raise x
4710 
    result = updateAsin_result()
4711 
    result.read(self._iprot)
4712 
    self._iprot.readMessageEnd()
4713 
    return
4714 
 
8739 vikram.rag 4715 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4716 
    """
4717 
    Parameters:
4718 
     - snapdealitem
4719 
    """
4720 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4721 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4722 
 
8739 vikram.rag 4723 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4724 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4725 
    args = addOrUpdateSnapdealItem_args()
4726 
    args.snapdealitem = snapdealitem
4727 
    args.write(self._oprot)
4728 
    self._oprot.writeMessageEnd()
4729 
    self._oprot.trans.flush()
4730 
 
4731 
  def recv_addOrUpdateSnapdealItem(self, ):
4732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4733 
    if mtype == TMessageType.EXCEPTION:
4734 
      x = TApplicationException()
4735 
      x.read(self._iprot)
4736 
      self._iprot.readMessageEnd()
4737 
      raise x
4738 
    result = addOrUpdateSnapdealItem_result()
4739 
    result.read(self._iprot)
4740 
    self._iprot.readMessageEnd()
4741 
    if result.success is not None:
4742 
      return result.success
4743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4744 
 
4745 
  def getSnapdealItem(self, item_id):
4746 
    """
4747 
    Parameters:
4748 
     - item_id
4749 
    """
4750 
    self.send_getSnapdealItem(item_id)
4751 
    return self.recv_getSnapdealItem()
4752 
 
4753 
  def send_getSnapdealItem(self, item_id):
4754 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4755 
    args = getSnapdealItem_args()
4756 
    args.item_id = item_id
4757 
    args.write(self._oprot)
4758 
    self._oprot.writeMessageEnd()
4759 
    self._oprot.trans.flush()
4760 
 
4761 
  def recv_getSnapdealItem(self, ):
4762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4763 
    if mtype == TMessageType.EXCEPTION:
4764 
      x = TApplicationException()
4765 
      x.read(self._iprot)
4766 
      self._iprot.readMessageEnd()
4767 
      raise x
4768 
    result = getSnapdealItem_result()
4769 
    result.read(self._iprot)
4770 
    self._iprot.readMessageEnd()
4771 
    if result.success is not None:
4772 
      return result.success
4773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4774 
 
9242 kshitij.so 4775 
  def getSnapdealItemDetails(self, item_id):
4776 
    """
4777 
    Parameters:
4778 
     - item_id
4779 
    """
4780 
    self.send_getSnapdealItemDetails(item_id)
4781 
    return self.recv_getSnapdealItemDetails()
4782 
 
4783 
  def send_getSnapdealItemDetails(self, item_id):
4784 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4785 
    args = getSnapdealItemDetails_args()
4786 
    args.item_id = item_id
4787 
    args.write(self._oprot)
4788 
    self._oprot.writeMessageEnd()
4789 
    self._oprot.trans.flush()
4790 
 
4791 
  def recv_getSnapdealItemDetails(self, ):
4792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4793 
    if mtype == TMessageType.EXCEPTION:
4794 
      x = TApplicationException()
4795 
      x.read(self._iprot)
4796 
      self._iprot.readMessageEnd()
4797 
      raise x
4798 
    result = getSnapdealItemDetails_result()
4799 
    result.read(self._iprot)
4800 
    self._iprot.readMessageEnd()
4801 
    if result.success is not None:
4802 
      return result.success
4803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4804 
 
8739 vikram.rag 4805 
  def getAllSnapdealItems(self, ):
4806 
    self.send_getAllSnapdealItems()
4807 
    return self.recv_getAllSnapdealItems()
4808 
 
4809 
  def send_getAllSnapdealItems(self, ):
4810 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4811 
    args = getAllSnapdealItems_args()
4812 
    args.write(self._oprot)
4813 
    self._oprot.writeMessageEnd()
4814 
    self._oprot.trans.flush()
4815 
 
4816 
  def recv_getAllSnapdealItems(self, ):
4817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4818 
    if mtype == TMessageType.EXCEPTION:
4819 
      x = TApplicationException()
4820 
      x.read(self._iprot)
4821 
      self._iprot.readMessageEnd()
4822 
      raise x
4823 
    result = getAllSnapdealItems_result()
4824 
    result.read(self._iprot)
4825 
    self._iprot.readMessageEnd()
4826 
    if result.success is not None:
4827 
      return result.success
4828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4829 
 
9242 kshitij.so 4830 
  def getSnapdealItems(self, offset, limit):
4831 
    """
4832 
    Parameters:
4833 
     - offset
4834 
     - limit
4835 
    """
4836 
    self.send_getSnapdealItems(offset, limit)
4837 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4838 
 
9242 kshitij.so 4839 
  def send_getSnapdealItems(self, offset, limit):
4840 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4841 
    args = getSnapdealItems_args()
4842 
    args.offset = offset
4843 
    args.limit = limit
4844 
    args.write(self._oprot)
4845 
    self._oprot.writeMessageEnd()
4846 
    self._oprot.trans.flush()
4847 
 
4848 
  def recv_getSnapdealItems(self, ):
4849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4850 
    if mtype == TMessageType.EXCEPTION:
4851 
      x = TApplicationException()
4852 
      x.read(self._iprot)
4853 
      self._iprot.readMessageEnd()
4854 
      raise x
4855 
    result = getSnapdealItems_result()
4856 
    result.read(self._iprot)
4857 
    self._iprot.readMessageEnd()
4858 
    if result.success is not None:
4859 
      return result.success
4860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4861 
 
4862 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4863 
    """
4864 
    Parameters:
4865 
     - searchTerm
4866 
     - offset
4867 
     - limit
4868 
    """
4869 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4870 
    return self.recv_searchSnapdealItems()
4871 
 
4872 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4873 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4874 
    args = searchSnapdealItems_args()
4875 
    args.searchTerm = searchTerm
4876 
    args.offset = offset
4877 
    args.limit = limit
4878 
    args.write(self._oprot)
4879 
    self._oprot.writeMessageEnd()
4880 
    self._oprot.trans.flush()
4881 
 
4882 
  def recv_searchSnapdealItems(self, ):
4883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4884 
    if mtype == TMessageType.EXCEPTION:
4885 
      x = TApplicationException()
4886 
      x.read(self._iprot)
4887 
      self._iprot.readMessageEnd()
4888 
      raise x
4889 
    result = searchSnapdealItems_result()
4890 
    result.read(self._iprot)
4891 
    self._iprot.readMessageEnd()
4892 
    if result.success is not None:
4893 
      return result.success
4894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4895 
 
4896 
  def getCountForSnapdealItems(self, ):
4897 
    self.send_getCountForSnapdealItems()
4898 
    return self.recv_getCountForSnapdealItems()
4899 
 
4900 
  def send_getCountForSnapdealItems(self, ):
4901 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4902 
    args = getCountForSnapdealItems_args()
4903 
    args.write(self._oprot)
4904 
    self._oprot.writeMessageEnd()
4905 
    self._oprot.trans.flush()
4906 
 
4907 
  def recv_getCountForSnapdealItems(self, ):
4908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4909 
    if mtype == TMessageType.EXCEPTION:
4910 
      x = TApplicationException()
4911 
      x.read(self._iprot)
4912 
      self._iprot.readMessageEnd()
4913 
      raise x
4914 
    result = getCountForSnapdealItems_result()
4915 
    result.read(self._iprot)
4916 
    self._iprot.readMessageEnd()
4917 
    if result.success is not None:
4918 
      return result.success
4919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
4920 
 
4921 
  def getSnapdealSearchResultCount(self, searchTerm):
4922 
    """
4923 
    Parameters:
4924 
     - searchTerm
4925 
    """
4926 
    self.send_getSnapdealSearchResultCount(searchTerm)
4927 
    return self.recv_getSnapdealSearchResultCount()
4928 
 
4929 
  def send_getSnapdealSearchResultCount(self, searchTerm):
4930 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
4931 
    args = getSnapdealSearchResultCount_args()
4932 
    args.searchTerm = searchTerm
4933 
    args.write(self._oprot)
4934 
    self._oprot.writeMessageEnd()
4935 
    self._oprot.trans.flush()
4936 
 
4937 
  def recv_getSnapdealSearchResultCount(self, ):
4938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4939 
    if mtype == TMessageType.EXCEPTION:
4940 
      x = TApplicationException()
4941 
      x.read(self._iprot)
4942 
      self._iprot.readMessageEnd()
4943 
      raise x
4944 
    result = getSnapdealSearchResultCount_result()
4945 
    result.read(self._iprot)
4946 
    self._iprot.readMessageEnd()
4947 
    if result.success is not None:
4948 
      return result.success
4949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
4950 
 
4951 
 
5944 mandeep.dh 4952 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4953 
  def __init__(self, handler):
4954 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4955 
    self._processMap["addItem"] = Processor.process_addItem
4956 
    self._processMap["updateItem"] = Processor.process_updateItem
4957 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4958 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4959 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4960 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4961 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4962 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4963 
    self._processMap["getItem"] = Processor.process_getItem
4964 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4965 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4966 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4967 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4968 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4969 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4970 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4971 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4972 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4973 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4974 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4975 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4976 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4977 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4978 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4979 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4980 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4981 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4982 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4983 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4984 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4985 
    self._processMap["addCategory"] = Processor.process_addCategory
4986 
    self._processMap["getCategory"] = Processor.process_getCategory
4987 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4988 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4989 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4990 
    self._processMap["addTag"] = Processor.process_addTag
4991 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4992 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4993 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4994 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4995 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4996 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4997 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4998 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4999 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5000 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5001 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5002 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5003 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5004 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5005 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5006 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5007 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5008 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5009 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5010 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5011 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5012 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5013 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5014 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5015 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5016 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5017 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5018 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5019 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5020 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5021 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5022 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5023 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5024 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5025 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5026 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5027 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5028 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5029 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5030 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5031 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5032 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5033 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5034 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5035 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5036 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5037 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5038 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5039 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5040 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5041 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5042 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5043 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5044 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5045 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5046 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5047 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5048 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5049 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5050 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5051 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5052 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5053 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5054 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5055 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5056 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5057 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5058 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5059 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5060 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5061 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5062 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5063 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5064 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5065 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5066 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5067 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5068 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5069 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5070 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5071 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5072 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5073 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5074 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5075 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5076 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5077 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5078 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5079 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5080 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5081 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5082 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5083 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5084 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
5944 mandeep.dh 5085 
 
5086 
  def process(self, iprot, oprot):
5087 
    (name, type, seqid) = iprot.readMessageBegin()
5088 
    if name not in self._processMap:
5089 
      iprot.skip(TType.STRUCT)
5090 
      iprot.readMessageEnd()
5091 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5092 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5093 
      x.write(oprot)
5094 
      oprot.writeMessageEnd()
5095 
      oprot.trans.flush()
5096 
      return
5097 
    else:
5098 
      self._processMap[name](self, seqid, iprot, oprot)
5099 
    return True
5100 
 
5101 
  def process_addItem(self, seqid, iprot, oprot):
5102 
    args = addItem_args()
5103 
    args.read(iprot)
5104 
    iprot.readMessageEnd()
5105 
    result = addItem_result()
5106 
    try:
5107 
      result.success = self._handler.addItem(args.item)
5108 
    except CatalogServiceException, cex:
5109 
      result.cex = cex
5110 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5111 
    result.write(oprot)
5112 
    oprot.writeMessageEnd()
5113 
    oprot.trans.flush()
5114 
 
5115 
  def process_updateItem(self, seqid, iprot, oprot):
5116 
    args = updateItem_args()
5117 
    args.read(iprot)
5118 
    iprot.readMessageEnd()
5119 
    result = updateItem_result()
5120 
    try:
5121 
      result.success = self._handler.updateItem(args.item)
5122 
    except CatalogServiceException, cex:
5123 
      result.cex = cex
5124 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5125 
    result.write(oprot)
5126 
    oprot.writeMessageEnd()
5127 
    oprot.trans.flush()
5128 
 
5129 
  def process_isActive(self, seqid, iprot, oprot):
5130 
    args = isActive_args()
5131 
    args.read(iprot)
5132 
    iprot.readMessageEnd()
5133 
    result = isActive_result()
5134 
    try:
5135 
      result.success = self._handler.isActive(args.itemId)
5136 
    except CatalogServiceException, isex:
5137 
      result.isex = isex
5138 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5139 
    result.write(oprot)
5140 
    oprot.writeMessageEnd()
5141 
    oprot.trans.flush()
5142 
 
7438 amit.gupta 5143 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5144 
    args = getItemsStatus_args()
5145 
    args.read(iprot)
5146 
    iprot.readMessageEnd()
5147 
    result = getItemsStatus_result()
5148 
    try:
5149 
      result.success = self._handler.getItemsStatus(args.itemIds)
5150 
    except CatalogServiceException, isex:
5151 
      result.isex = isex
5152 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5153 
    result.write(oprot)
5154 
    oprot.writeMessageEnd()
5155 
    oprot.trans.flush()
5156 
 
5944 mandeep.dh 5157 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5158 
    args = getItemStatusDescription_args()
5159 
    args.read(iprot)
5160 
    iprot.readMessageEnd()
5161 
    result = getItemStatusDescription_result()
5162 
    try:
5163 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5164 
    except CatalogServiceException, isex:
5165 
      result.isex = isex
5166 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5167 
    result.write(oprot)
5168 
    oprot.writeMessageEnd()
5169 
    oprot.trans.flush()
5170 
 
5171 
  def process_startItemOn(self, seqid, iprot, oprot):
5172 
    args = startItemOn_args()
5173 
    args.read(iprot)
5174 
    iprot.readMessageEnd()
5175 
    result = startItemOn_result()
5176 
    try:
5177 
      self._handler.startItemOn(args.item_id, args.timestamp)
5178 
    except CatalogServiceException, cex:
5179 
      result.cex = cex
5180 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5181 
    result.write(oprot)
5182 
    oprot.writeMessageEnd()
5183 
    oprot.trans.flush()
5184 
 
5185 
  def process_retireItemOn(self, seqid, iprot, oprot):
5186 
    args = retireItemOn_args()
5187 
    args.read(iprot)
5188 
    iprot.readMessageEnd()
5189 
    result = retireItemOn_result()
5190 
    try:
5191 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5192 
    except CatalogServiceException, cex:
5193 
      result.cex = cex
5194 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5195 
    result.write(oprot)
5196 
    oprot.writeMessageEnd()
5197 
    oprot.trans.flush()
5198 
 
5199 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5200 
    args = changeItemStatus_args()
5201 
    args.read(iprot)
5202 
    iprot.readMessageEnd()
5203 
    result = changeItemStatus_result()
5204 
    try:
5205 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5206 
    except CatalogServiceException, cex:
5207 
      result.cex = cex
5208 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5209 
    result.write(oprot)
5210 
    oprot.writeMessageEnd()
5211 
    oprot.trans.flush()
5212 
 
5213 
  def process_getItem(self, seqid, iprot, oprot):
5214 
    args = getItem_args()
5215 
    args.read(iprot)
5216 
    iprot.readMessageEnd()
5217 
    result = getItem_result()
5218 
    try:
5219 
      result.success = self._handler.getItem(args.item_id)
5220 
    except CatalogServiceException, cex:
5221 
      result.cex = cex
5222 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5223 
    result.write(oprot)
5224 
    oprot.writeMessageEnd()
5225 
    oprot.trans.flush()
5226 
 
5227 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5228 
    args = getItemsByCatalogId_args()
5229 
    args.read(iprot)
5230 
    iprot.readMessageEnd()
5231 
    result = getItemsByCatalogId_result()
5232 
    try:
5233 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5234 
    except CatalogServiceException, cex:
5235 
      result.cex = cex
5236 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5237 
    result.write(oprot)
5238 
    oprot.writeMessageEnd()
5239 
    oprot.trans.flush()
5240 
 
5241 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5242 
    args = getValidItemsByCatalogId_args()
5243 
    args.read(iprot)
5244 
    iprot.readMessageEnd()
5245 
    result = getValidItemsByCatalogId_result()
5246 
    try:
5247 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5248 
    except CatalogServiceException, cex:
5249 
      result.cex = cex
5250 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5251 
    result.write(oprot)
5252 
    oprot.writeMessageEnd()
5253 
    oprot.trans.flush()
5254 
 
5255 
  def process_getAllItems(self, seqid, iprot, oprot):
5256 
    args = getAllItems_args()
5257 
    args.read(iprot)
5258 
    iprot.readMessageEnd()
5259 
    result = getAllItems_result()
5260 
    try:
5261 
      result.success = self._handler.getAllItems(args.isActive)
5262 
    except CatalogServiceException, cex:
5263 
      result.cex = cex
5264 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5265 
    result.write(oprot)
5266 
    oprot.writeMessageEnd()
5267 
    oprot.trans.flush()
5268 
 
5269 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5270 
    args = getAllItemsByStatus_args()
5271 
    args.read(iprot)
5272 
    iprot.readMessageEnd()
5273 
    result = getAllItemsByStatus_result()
5274 
    try:
5275 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5276 
    except CatalogServiceException, cex:
5277 
      result.cex = cex
5278 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5279 
    result.write(oprot)
5280 
    oprot.writeMessageEnd()
5281 
    oprot.trans.flush()
5282 
 
5283 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5284 
    args = markItemAsContentComplete_args()
5285 
    args.read(iprot)
5286 
    iprot.readMessageEnd()
5287 
    result = markItemAsContentComplete_result()
5288 
    try:
9253 rajveer 5289 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5290 
    except CatalogServiceException, cex:
5291 
      result.cex = cex
5292 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5293 
    result.write(oprot)
5294 
    oprot.writeMessageEnd()
5295 
    oprot.trans.flush()
5296 
 
5297 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5298 
    args = getAllItemsInRange_args()
5299 
    args.read(iprot)
5300 
    iprot.readMessageEnd()
5301 
    result = getAllItemsInRange_result()
5302 
    try:
5303 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5304 
    except CatalogServiceException, cex:
5305 
      result.cex = cex
5306 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5307 
    result.write(oprot)
5308 
    oprot.writeMessageEnd()
5309 
    oprot.trans.flush()
5310 
 
5311 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5312 
    args = getAllItemsByStatusInRange_args()
5313 
    args.read(iprot)
5314 
    iprot.readMessageEnd()
5315 
    result = getAllItemsByStatusInRange_result()
5316 
    try:
5317 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5318 
    except CatalogServiceException, cex:
5319 
      result.cex = cex
5320 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
5325 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5326 
    args = getItemCountByStatus_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = getItemCountByStatus_result()
5330 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5331 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5332 
    result.write(oprot)
5333 
    oprot.writeMessageEnd()
5334 
    oprot.trans.flush()
5335 
 
5336 
  def process_getBestSellers(self, seqid, iprot, oprot):
5337 
    args = getBestSellers_args()
5338 
    args.read(iprot)
5339 
    iprot.readMessageEnd()
5340 
    result = getBestSellers_result()
5341 
    try:
5342 
      result.success = self._handler.getBestSellers()
5343 
    except CatalogServiceException, isex:
5344 
      result.isex = isex
5345 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5346 
    result.write(oprot)
5347 
    oprot.writeMessageEnd()
5348 
    oprot.trans.flush()
5349 
 
5350 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5351 
    args = getBestSellersCatalogIds_args()
5352 
    args.read(iprot)
5353 
    iprot.readMessageEnd()
5354 
    result = getBestSellersCatalogIds_result()
5355 
    try:
5356 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5357 
    except CatalogServiceException, cex:
5358 
      result.cex = cex
5359 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5360 
    result.write(oprot)
5361 
    oprot.writeMessageEnd()
5362 
    oprot.trans.flush()
5363 
 
5364 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5365 
    args = getBestSellersCount_args()
5366 
    args.read(iprot)
5367 
    iprot.readMessageEnd()
5368 
    result = getBestSellersCount_result()
5369 
    try:
5370 
      result.success = self._handler.getBestSellersCount()
5371 
    except CatalogServiceException, cex:
5372 
      result.cex = cex
5373 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5374 
    result.write(oprot)
5375 
    oprot.writeMessageEnd()
5376 
    oprot.trans.flush()
5377 
 
5378 
  def process_getBestDeals(self, seqid, iprot, oprot):
5379 
    args = getBestDeals_args()
5380 
    args.read(iprot)
5381 
    iprot.readMessageEnd()
5382 
    result = getBestDeals_result()
5383 
    try:
5384 
      result.success = self._handler.getBestDeals()
5385 
    except CatalogServiceException, isex:
5386 
      result.isex = isex
5387 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5388 
    result.write(oprot)
5389 
    oprot.writeMessageEnd()
5390 
    oprot.trans.flush()
5391 
 
5392 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5393 
    args = getBestDealsCatalogIds_args()
5394 
    args.read(iprot)
5395 
    iprot.readMessageEnd()
5396 
    result = getBestDealsCatalogIds_result()
5397 
    try:
5398 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5399 
    except CatalogServiceException, cex:
5400 
      result.cex = cex
5401 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5402 
    result.write(oprot)
5403 
    oprot.writeMessageEnd()
5404 
    oprot.trans.flush()
5405 
 
5406 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5407 
    args = getBestDealsCount_args()
5408 
    args.read(iprot)
5409 
    iprot.readMessageEnd()
5410 
    result = getBestDealsCount_result()
5411 
    try:
5412 
      result.success = self._handler.getBestDealsCount()
5413 
    except CatalogServiceException, cex:
5414 
      result.cex = cex
5415 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5416 
    result.write(oprot)
5417 
    oprot.writeMessageEnd()
5418 
    oprot.trans.flush()
5419 
 
5420 
  def process_getComingSoon(self, seqid, iprot, oprot):
5421 
    args = getComingSoon_args()
5422 
    args.read(iprot)
5423 
    iprot.readMessageEnd()
5424 
    result = getComingSoon_result()
5425 
    try:
5426 
      result.success = self._handler.getComingSoon()
5427 
    except CatalogServiceException, isex:
5428 
      result.isex = isex
5429 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5430 
    result.write(oprot)
5431 
    oprot.writeMessageEnd()
5432 
    oprot.trans.flush()
5433 
 
5434 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5435 
    args = getComingSoonCatalogIds_args()
5436 
    args.read(iprot)
5437 
    iprot.readMessageEnd()
5438 
    result = getComingSoonCatalogIds_result()
5439 
    try:
5440 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5441 
    except CatalogServiceException, cex:
5442 
      result.cex = cex
5443 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5444 
    result.write(oprot)
5445 
    oprot.writeMessageEnd()
5446 
    oprot.trans.flush()
5447 
 
5448 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5449 
    args = getComingSoonCount_args()
5450 
    args.read(iprot)
5451 
    iprot.readMessageEnd()
5452 
    result = getComingSoonCount_result()
5453 
    try:
5454 
      result.success = self._handler.getComingSoonCount()
5455 
    except CatalogServiceException, cex:
5456 
      result.cex = cex
5457 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5458 
    result.write(oprot)
5459 
    oprot.writeMessageEnd()
5460 
    oprot.trans.flush()
5461 
 
5462 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5463 
    args = getLatestArrivals_args()
5464 
    args.read(iprot)
5465 
    iprot.readMessageEnd()
5466 
    result = getLatestArrivals_result()
5467 
    try:
5468 
      result.success = self._handler.getLatestArrivals()
5469 
    except CatalogServiceException, isex:
5470 
      result.isex = isex
5471 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5472 
    result.write(oprot)
5473 
    oprot.writeMessageEnd()
5474 
    oprot.trans.flush()
5475 
 
5476 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5477 
    args = getLatestArrivalsCatalogIds_args()
5478 
    args.read(iprot)
5479 
    iprot.readMessageEnd()
5480 
    result = getLatestArrivalsCatalogIds_result()
5481 
    try:
5482 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5483 
    except CatalogServiceException, cex:
5484 
      result.cex = cex
5485 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5486 
    result.write(oprot)
5487 
    oprot.writeMessageEnd()
5488 
    oprot.trans.flush()
5489 
 
5490 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5491 
    args = getLatestArrivalsCount_args()
5492 
    args.read(iprot)
5493 
    iprot.readMessageEnd()
5494 
    result = getLatestArrivalsCount_result()
5495 
    try:
5496 
      result.success = self._handler.getLatestArrivalsCount()
5497 
    except CatalogServiceException, cex:
5498 
      result.cex = cex
5499 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5500 
    result.write(oprot)
5501 
    oprot.writeMessageEnd()
5502 
    oprot.trans.flush()
5503 
 
5504 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5505 
    args = generateNewEntityID_args()
5506 
    args.read(iprot)
5507 
    iprot.readMessageEnd()
5508 
    result = generateNewEntityID_result()
5509 
    result.success = self._handler.generateNewEntityID()
5510 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5511 
    result.write(oprot)
5512 
    oprot.writeMessageEnd()
5513 
    oprot.trans.flush()
5514 
 
5515 
  def process_addCategory(self, seqid, iprot, oprot):
5516 
    args = addCategory_args()
5517 
    args.read(iprot)
5518 
    iprot.readMessageEnd()
5519 
    result = addCategory_result()
5520 
    result.success = self._handler.addCategory(args.category)
5521 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5522 
    result.write(oprot)
5523 
    oprot.writeMessageEnd()
5524 
    oprot.trans.flush()
5525 
 
5526 
  def process_getCategory(self, seqid, iprot, oprot):
5527 
    args = getCategory_args()
5528 
    args.read(iprot)
5529 
    iprot.readMessageEnd()
5530 
    result = getCategory_result()
5531 
    result.success = self._handler.getCategory(args.id)
5532 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5533 
    result.write(oprot)
5534 
    oprot.writeMessageEnd()
5535 
    oprot.trans.flush()
5536 
 
5537 
  def process_getAllCategories(self, seqid, iprot, oprot):
5538 
    args = getAllCategories_args()
5539 
    args.read(iprot)
5540 
    iprot.readMessageEnd()
5541 
    result = getAllCategories_result()
5542 
    result.success = self._handler.getAllCategories()
5543 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5544 
    result.write(oprot)
5545 
    oprot.writeMessageEnd()
5546 
    oprot.trans.flush()
5547 
 
5548 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5549 
    args = getAllSimilarItems_args()
5550 
    args.read(iprot)
5551 
    iprot.readMessageEnd()
5552 
    result = getAllSimilarItems_result()
5553 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5554 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5555 
    result.write(oprot)
5556 
    oprot.writeMessageEnd()
5557 
    oprot.trans.flush()
5558 
 
5559 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5560 
    args = addSimilarItem_args()
5561 
    args.read(iprot)
5562 
    iprot.readMessageEnd()
5563 
    result = addSimilarItem_result()
5564 
    try:
5565 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5566 
    except CatalogServiceException, cex:
5567 
      result.cex = cex
5568 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5569 
    result.write(oprot)
5570 
    oprot.writeMessageEnd()
5571 
    oprot.trans.flush()
5572 
 
6512 kshitij.so 5573 
  def process_addTag(self, seqid, iprot, oprot):
5574 
    args = addTag_args()
5575 
    args.read(iprot)
5576 
    iprot.readMessageEnd()
5577 
    result = addTag_result()
5578 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5579 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5580 
    result.write(oprot)
5581 
    oprot.writeMessageEnd()
5582 
    oprot.trans.flush()
5583 
 
5584 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5585 
    args = deleteEntityTag_args()
5586 
    args.read(iprot)
5587 
    iprot.readMessageEnd()
5588 
    result = deleteEntityTag_result()
5589 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5590 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5591 
    result.write(oprot)
5592 
    oprot.writeMessageEnd()
5593 
    oprot.trans.flush()
5594 
 
5595 
  def process_deleteTag(self, seqid, iprot, oprot):
5596 
    args = deleteTag_args()
5597 
    args.read(iprot)
5598 
    iprot.readMessageEnd()
5599 
    result = deleteTag_result()
5600 
    result.success = self._handler.deleteTag(args.displayName)
5601 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5602 
    result.write(oprot)
5603 
    oprot.writeMessageEnd()
5604 
    oprot.trans.flush()
5605 
 
5606 
  def process_getAllTags(self, seqid, iprot, oprot):
5607 
    args = getAllTags_args()
5608 
    args.read(iprot)
5609 
    iprot.readMessageEnd()
5610 
    result = getAllTags_result()
5611 
    result.success = self._handler.getAllTags()
5612 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5613 
    result.write(oprot)
5614 
    oprot.writeMessageEnd()
5615 
    oprot.trans.flush()
5616 
 
5617 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5618 
    args = getAllEntitiesByTagName_args()
5619 
    args.read(iprot)
5620 
    iprot.readMessageEnd()
5621 
    result = getAllEntitiesByTagName_result()
5622 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5623 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5624 
    result.write(oprot)
5625 
    oprot.writeMessageEnd()
5626 
    oprot.trans.flush()
5627 
 
6845 amit.gupta 5628 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5629 
    args = getAllEntityTags_args()
5630 
    args.read(iprot)
5631 
    iprot.readMessageEnd()
5632 
    result = getAllEntityTags_result()
5633 
    result.success = self._handler.getAllEntityTags()
5634 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5635 
    result.write(oprot)
5636 
    oprot.writeMessageEnd()
5637 
    oprot.trans.flush()
5638 
 
6850 kshitij.so 5639 
  def process_addBanner(self, seqid, iprot, oprot):
5640 
    args = addBanner_args()
5641 
    args.read(iprot)
5642 
    iprot.readMessageEnd()
5643 
    result = addBanner_result()
8590 kshitij.so 5644 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5645 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5646 
    result.write(oprot)
5647 
    oprot.writeMessageEnd()
5648 
    oprot.trans.flush()
5649 
 
8579 kshitij.so 5650 
  def process_updateBanner(self, seqid, iprot, oprot):
5651 
    args = updateBanner_args()
5652 
    args.read(iprot)
5653 
    iprot.readMessageEnd()
5654 
    result = updateBanner_result()
5655 
    result.success = self._handler.updateBanner(args.banner)
5656 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5657 
    result.write(oprot)
5658 
    oprot.writeMessageEnd()
5659 
    oprot.trans.flush()
5660 
 
6850 kshitij.so 5661 
  def process_getAllBanners(self, seqid, iprot, oprot):
5662 
    args = getAllBanners_args()
5663 
    args.read(iprot)
5664 
    iprot.readMessageEnd()
5665 
    result = getAllBanners_result()
5666 
    result.success = self._handler.getAllBanners()
5667 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5668 
    result.write(oprot)
5669 
    oprot.writeMessageEnd()
5670 
    oprot.trans.flush()
5671 
 
5672 
  def process_deleteBanner(self, seqid, iprot, oprot):
5673 
    args = deleteBanner_args()
5674 
    args.read(iprot)
5675 
    iprot.readMessageEnd()
5676 
    result = deleteBanner_result()
9155 kshitij.so 5677 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 5678 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5679 
    result.write(oprot)
5680 
    oprot.writeMessageEnd()
5681 
    oprot.trans.flush()
5682 
 
5683 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5684 
    args = getBannerDetails_args()
5685 
    args.read(iprot)
5686 
    iprot.readMessageEnd()
5687 
    result = getBannerDetails_result()
9155 kshitij.so 5688 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 5689 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5690 
    result.write(oprot)
5691 
    oprot.writeMessageEnd()
5692 
    oprot.trans.flush()
5693 
 
5694 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5695 
    args = getActiveBanners_args()
5696 
    args.read(iprot)
5697 
    iprot.readMessageEnd()
5698 
    result = getActiveBanners_result()
5699 
    result.success = self._handler.getActiveBanners()
5700 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
6849 kshitij.so 5705 
  def process_addBannerMap(self, seqid, iprot, oprot):
5706 
    args = addBannerMap_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = addBannerMap_result()
8579 kshitij.so 5710 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5711 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5712 
    result.write(oprot)
5713 
    oprot.writeMessageEnd()
5714 
    oprot.trans.flush()
5715 
 
8579 kshitij.so 5716 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5717 
    args = updateBannerMap_args()
5718 
    args.read(iprot)
5719 
    iprot.readMessageEnd()
5720 
    result = updateBannerMap_result()
5721 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5722 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5723 
    result.write(oprot)
5724 
    oprot.writeMessageEnd()
5725 
    oprot.trans.flush()
5726 
 
6849 kshitij.so 5727 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5728 
    args = deleteBannerMap_args()
5729 
    args.read(iprot)
5730 
    iprot.readMessageEnd()
5731 
    result = deleteBannerMap_result()
5732 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5733 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5734 
    result.write(oprot)
5735 
    oprot.writeMessageEnd()
5736 
    oprot.trans.flush()
5737 
 
5738 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5739 
    args = getBannerMapDetails_args()
5740 
    args.read(iprot)
5741 
    iprot.readMessageEnd()
5742 
    result = getBannerMapDetails_result()
9155 kshitij.so 5743 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 5744 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5745 
    result.write(oprot)
5746 
    oprot.writeMessageEnd()
5747 
    oprot.trans.flush()
5748 
 
8579 kshitij.so 5749 
  def process_addBannerUri(self, seqid, iprot, oprot):
5750 
    args = addBannerUri_args()
5751 
    args.read(iprot)
5752 
    iprot.readMessageEnd()
5753 
    result = addBannerUri_result()
5754 
    self._handler.addBannerUri(args.bannerUriMappings)
5755 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
5759 
 
5760 
  def process_getUriMapping(self, seqid, iprot, oprot):
5761 
    args = getUriMapping_args()
5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
5764 
    result = getUriMapping_result()
9155 kshitij.so 5765 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 5766 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5767 
    result.write(oprot)
5768 
    oprot.writeMessageEnd()
5769 
    oprot.trans.flush()
5770 
 
5771 
  def process_addCampaign(self, seqid, iprot, oprot):
5772 
    args = addCampaign_args()
5773 
    args.read(iprot)
5774 
    iprot.readMessageEnd()
5775 
    result = addCampaign_result()
5776 
    self._handler.addCampaign(args.campaign)
5777 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5778 
    result.write(oprot)
5779 
    oprot.writeMessageEnd()
5780 
    oprot.trans.flush()
5781 
 
5782 
  def process_getCampaigns(self, seqid, iprot, oprot):
5783 
    args = getCampaigns_args()
5784 
    args.read(iprot)
5785 
    iprot.readMessageEnd()
5786 
    result = getCampaigns_result()
5787 
    result.success = self._handler.getCampaigns(args.campaignName)
5788 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5789 
    result.write(oprot)
5790 
    oprot.writeMessageEnd()
5791 
    oprot.trans.flush()
5792 
 
5793 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5794 
    args = deleteCampaign_args()
5795 
    args.read(iprot)
5796 
    iprot.readMessageEnd()
5797 
    result = deleteCampaign_result()
5798 
    self._handler.deleteCampaign(args.campaignId)
5799 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
5804 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5805 
    args = getAllCampaigns_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = getAllCampaigns_result()
5809 
    result.success = self._handler.getAllCampaigns()
5810 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5811 
    result.write(oprot)
5812 
    oprot.writeMessageEnd()
5813 
    oprot.trans.flush()
5814 
 
9155 kshitij.so 5815 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
5816 
    args = getActiveBannersForMobileSite_args()
5817 
    args.read(iprot)
5818 
    iprot.readMessageEnd()
5819 
    result = getActiveBannersForMobileSite_result()
5820 
    result.success = self._handler.getActiveBannersForMobileSite()
5821 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
5822 
    result.write(oprot)
5823 
    oprot.writeMessageEnd()
5824 
    oprot.trans.flush()
5825 
 
5944 mandeep.dh 5826 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5827 
    args = deleteSimilarItem_args()
5828 
    args.read(iprot)
5829 
    iprot.readMessageEnd()
5830 
    result = deleteSimilarItem_result()
5831 
    try:
5832 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5833 
    except CatalogServiceException, cex:
5834 
      result.cex = cex
5835 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5836 
    result.write(oprot)
5837 
    oprot.writeMessageEnd()
5838 
    oprot.trans.flush()
5839 
 
5840 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5841 
    args = checkSimilarItem_args()
5842 
    args.read(iprot)
5843 
    iprot.readMessageEnd()
5844 
    result = checkSimilarItem_result()
5845 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5846 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5847 
    result.write(oprot)
5848 
    oprot.writeMessageEnd()
5849 
    oprot.trans.flush()
5850 
 
5851 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5852 
    args = validateRiskyStatus_args()
5853 
    args.read(iprot)
5854 
    iprot.readMessageEnd()
5855 
    result = validateRiskyStatus_result()
5856 
    self._handler.validateRiskyStatus(args.itemId)
5857 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
5862 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5863 
    args = changeItemRiskyFlag_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = changeItemRiskyFlag_result()
5867 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5868 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
5872 
 
5873 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5874 
    args = getItemsByRiskyFlag_args()
5875 
    args.read(iprot)
5876 
    iprot.readMessageEnd()
5877 
    result = getItemsByRiskyFlag_result()
5878 
    result.success = self._handler.getItemsByRiskyFlag()
5879 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
5884 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5885 
    args = getItemsForMasterSheet_args()
5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
5888 
    result = getItemsForMasterSheet_result()
5889 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5890 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5891 
    result.write(oprot)
5892 
    oprot.writeMessageEnd()
5893 
    oprot.trans.flush()
5894 
 
5895 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5896 
    args = getSimilarItemsCatalogIds_args()
5897 
    args.read(iprot)
5898 
    iprot.readMessageEnd()
5899 
    result = getSimilarItemsCatalogIds_result()
5900 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5901 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5902 
    result.write(oprot)
5903 
    oprot.writeMessageEnd()
5904 
    oprot.trans.flush()
5905 
 
5906 
  def process_addProductNotification(self, seqid, iprot, oprot):
5907 
    args = addProductNotification_args()
5908 
    args.read(iprot)
5909 
    iprot.readMessageEnd()
5910 
    result = addProductNotification_result()
5911 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5912 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5913 
    result.write(oprot)
5914 
    oprot.writeMessageEnd()
5915 
    oprot.trans.flush()
5916 
 
5917 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5918 
    args = sendProductNotifications_args()
5919 
    args.read(iprot)
5920 
    iprot.readMessageEnd()
5921 
    result = sendProductNotifications_result()
5922 
    result.success = self._handler.sendProductNotifications()
5923 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
5927 
 
5928 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5929 
    args = getAllBrandsByCategory_args()
5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
5932 
    result = getAllBrandsByCategory_result()
5933 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5934 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5935 
    result.write(oprot)
5936 
    oprot.writeMessageEnd()
5937 
    oprot.trans.flush()
5938 
 
5939 
  def process_getAllBrands(self, seqid, iprot, oprot):
5940 
    args = getAllBrands_args()
5941 
    args.read(iprot)
5942 
    iprot.readMessageEnd()
5943 
    result = getAllBrands_result()
5944 
    result.success = self._handler.getAllBrands()
5945 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
5950 
  def process_getAllSources(self, seqid, iprot, oprot):
5951 
    args = getAllSources_args()
5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
5954 
    result = getAllSources_result()
5955 
    result.success = self._handler.getAllSources()
5956 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
5960 
 
5961 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5962 
    args = getItemPricingBySource_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = getItemPricingBySource_result()
5966 
    try:
5967 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5968 
    except CatalogServiceException, cex:
5969 
      result.cex = cex
5970 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5971 
    result.write(oprot)
5972 
    oprot.writeMessageEnd()
5973 
    oprot.trans.flush()
5974 
 
5975 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5976 
    args = addSourceItemPricing_args()
5977 
    args.read(iprot)
5978 
    iprot.readMessageEnd()
5979 
    result = addSourceItemPricing_result()
5980 
    try:
5981 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5982 
    except CatalogServiceException, cex:
5983 
      result.cex = cex
5984 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5985 
    result.write(oprot)
5986 
    oprot.writeMessageEnd()
5987 
    oprot.trans.flush()
5988 
 
5989 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5990 
    args = getAllSourcePricing_args()
5991 
    args.read(iprot)
5992 
    iprot.readMessageEnd()
5993 
    result = getAllSourcePricing_result()
5994 
    try:
5995 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5996 
    except CatalogServiceException, cex:
5997 
      result.cex = cex
5998 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5999 
    result.write(oprot)
6000 
    oprot.writeMessageEnd()
6001 
    oprot.trans.flush()
6002 
 
6003 
  def process_getItemForSource(self, seqid, iprot, oprot):
6004 
    args = getItemForSource_args()
6005 
    args.read(iprot)
6006 
    iprot.readMessageEnd()
6007 
    result = getItemForSource_result()
6008 
    try:
6009 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6010 
    except CatalogServiceException, cex:
6011 
      result.cex = cex
6012 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6013 
    result.write(oprot)
6014 
    oprot.writeMessageEnd()
6015 
    oprot.trans.flush()
6016 
 
6017 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6018 
    args = searchItemsInRange_args()
6019 
    args.read(iprot)
6020 
    iprot.readMessageEnd()
6021 
    result = searchItemsInRange_result()
6022 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6023 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6024 
    result.write(oprot)
6025 
    oprot.writeMessageEnd()
6026 
    oprot.trans.flush()
6027 
 
6028 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6029 
    args = getSearchResultCount_args()
6030 
    args.read(iprot)
6031 
    iprot.readMessageEnd()
6032 
    result = getSearchResultCount_result()
6033 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6034 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6035 
    result.write(oprot)
6036 
    oprot.writeMessageEnd()
6037 
    oprot.trans.flush()
6038 
 
6039 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6040 
    args = getProductNotifications_args()
6041 
    args.read(iprot)
6042 
    iprot.readMessageEnd()
6043 
    result = getProductNotifications_result()
6044 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6045 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6046 
    result.write(oprot)
6047 
    oprot.writeMessageEnd()
6048 
    oprot.trans.flush()
6049 
 
6050 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6051 
    args = getProductNotificationRequestCount_args()
6052 
    args.read(iprot)
6053 
    iprot.readMessageEnd()
6054 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6055 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6056 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6057 
    result.write(oprot)
6058 
    oprot.writeMessageEnd()
6059 
    oprot.trans.flush()
6060 
 
6061 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6062 
    args = addAuthorizationLog_args()
6063 
    args.read(iprot)
6064 
    iprot.readMessageEnd()
6065 
    result = addAuthorizationLog_result()
6066 
    try:
6067 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6068 
    except CatalogServiceException, cex:
6069 
      result.cex = cex
6070 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6071 
    result.write(oprot)
6072 
    oprot.writeMessageEnd()
6073 
    oprot.trans.flush()
6074 
 
6075 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6076 
    args = addupdateVoucherForItem_args()
6077 
    args.read(iprot)
6078 
    iprot.readMessageEnd()
6079 
    result = addupdateVoucherForItem_result()
6080 
    try:
6081 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6082 
    except CatalogServiceException, cex:
6083 
      result.cex = cex
6084 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6085 
    result.write(oprot)
6086 
    oprot.writeMessageEnd()
6087 
    oprot.trans.flush()
6088 
 
6089 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6090 
    args = deleteVoucherForItem_args()
6091 
    args.read(iprot)
6092 
    iprot.readMessageEnd()
6093 
    result = deleteVoucherForItem_result()
6094 
    try:
6095 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6096 
    except CatalogServiceException, cex:
6097 
      result.cex = cex
6098 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6099 
    result.write(oprot)
6100 
    oprot.writeMessageEnd()
6101 
    oprot.trans.flush()
6102 
 
6103 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6104 
    args = getVoucherAmount_args()
6105 
    args.read(iprot)
6106 
    iprot.readMessageEnd()
6107 
    result = getVoucherAmount_result()
6108 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6109 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6110 
    result.write(oprot)
6111 
    oprot.writeMessageEnd()
6112 
    oprot.trans.flush()
6113 
 
6114 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6115 
    args = getAllItemVouchers_args()
6116 
    args.read(iprot)
6117 
    iprot.readMessageEnd()
6118 
    result = getAllItemVouchers_result()
6119 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6120 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
6125 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6126 
    args = isValidCatalogItemId_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = isValidCatalogItemId_result()
6130 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6131 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
6135 
 
6039 amit.gupta 6136 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6137 
    args = getVatPercentageForItem_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6141 
    try:
6142 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6143 
    except CatalogServiceException, cex:
6144 
      result.cex = cex
6039 amit.gupta 6145 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6146 
    result.write(oprot)
6147 
    oprot.writeMessageEnd()
6148 
    oprot.trans.flush()
5944 mandeep.dh 6149 
 
6039 amit.gupta 6150 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6151 
    args = getVatAmountForItem_args()
6152 
    args.read(iprot)
6153 
    iprot.readMessageEnd()
6154 
    result = getVatAmountForItem_result()
6155 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6156 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
6531 vikram.rag 6161 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6162 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6166 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6167 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6168 
    result.write(oprot)
6169 
    oprot.writeMessageEnd()
6170 
    oprot.trans.flush()
6039 amit.gupta 6171 
 
6821 amar.kumar 6172 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6173 
    args = getAllAliveItems_args()
6174 
    args.read(iprot)
6175 
    iprot.readMessageEnd()
6176 
    result = getAllAliveItems_result()
6177 
    result.success = self._handler.getAllAliveItems()
6178 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6179 
    result.write(oprot)
6180 
    oprot.writeMessageEnd()
6181 
    oprot.trans.flush()
6182 
 
6805 anupam.sin 6183 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6184 
    args = getInsuranceAmount_args()
6185 
    args.read(iprot)
6186 
    iprot.readMessageEnd()
6187 
    result = getInsuranceAmount_result()
6921 anupam.sin 6188 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6189 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6190 
    result.write(oprot)
6191 
    oprot.writeMessageEnd()
6192 
    oprot.trans.flush()
6531 vikram.rag 6193 
 
6805 anupam.sin 6194 
  def process_getInsurer(self, seqid, iprot, oprot):
6195 
    args = getInsurer_args()
6196 
    args.read(iprot)
6197 
    iprot.readMessageEnd()
6198 
    result = getInsurer_result()
6199 
    result.success = self._handler.getInsurer(args.insurerId)
6200 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6201 
    result.write(oprot)
6202 
    oprot.writeMessageEnd()
6203 
    oprot.trans.flush()
6204 
 
6838 vikram.rag 6205 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6206 
    args = getAllInsurers_args()
6207 
    args.read(iprot)
6208 
    iprot.readMessageEnd()
6209 
    result = getAllInsurers_result()
6210 
    result.success = self._handler.getAllInsurers()
6211 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6212 
    result.write(oprot)
6213 
    oprot.writeMessageEnd()
6214 
    oprot.trans.flush()
6805 anupam.sin 6215 
 
6962 rajveer 6216 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6217 
    args = updateInsuranceDeclaredAmount_args()
6218 
    args.read(iprot)
6219 
    iprot.readMessageEnd()
6220 
    result = updateInsuranceDeclaredAmount_result()
6221 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6222 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6223 
    result.write(oprot)
6224 
    oprot.writeMessageEnd()
6225 
    oprot.trans.flush()
6838 vikram.rag 6226 
 
7190 amar.kumar 6227 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6228 
    args = getFreebieForItem_args()
6229 
    args.read(iprot)
6230 
    iprot.readMessageEnd()
6231 
    result = getFreebieForItem_result()
6232 
    result.success = self._handler.getFreebieForItem(args.itemId)
6233 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6234 
    result.write(oprot)
6235 
    oprot.writeMessageEnd()
6236 
    oprot.trans.flush()
6962 rajveer 6237 
 
7190 amar.kumar 6238 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6239 
    args = addOrUpdateFreebieForItem_args()
6240 
    args.read(iprot)
6241 
    iprot.readMessageEnd()
6242 
    result = addOrUpdateFreebieForItem_result()
6243 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6244 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6245 
    result.write(oprot)
6246 
    oprot.writeMessageEnd()
6247 
    oprot.trans.flush()
6248 
 
7272 amit.gupta 6249 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6250 
    args = addOrUpdateBrandInfo_args()
6251 
    args.read(iprot)
6252 
    iprot.readMessageEnd()
6253 
    result = addOrUpdateBrandInfo_result()
6254 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6255 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6256 
    result.write(oprot)
6257 
    oprot.writeMessageEnd()
6258 
    oprot.trans.flush()
6259 
 
6260 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6261 
    args = getBrandInfo_args()
6262 
    args.read(iprot)
6263 
    iprot.readMessageEnd()
6264 
    result = getBrandInfo_result()
6265 
    result.success = self._handler.getBrandInfo()
6266 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6267 
    result.write(oprot)
6268 
    oprot.writeMessageEnd()
6269 
    oprot.trans.flush()
6270 
 
7256 rajveer 6271 
  def process_getStorePricing(self, seqid, iprot, oprot):
6272 
    args = getStorePricing_args()
6273 
    args.read(iprot)
6274 
    iprot.readMessageEnd()
6275 
    result = getStorePricing_result()
6276 
    result.success = self._handler.getStorePricing(args.itemId)
6277 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6278 
    result.write(oprot)
6279 
    oprot.writeMessageEnd()
6280 
    oprot.trans.flush()
7190 amar.kumar 6281 
 
7306 rajveer 6282 
  def process_getStorePricings(self, seqid, iprot, oprot):
6283 
    args = getStorePricings_args()
6284 
    args.read(iprot)
6285 
    iprot.readMessageEnd()
6286 
    result = getStorePricings_result()
6287 
    result.success = self._handler.getStorePricings(args.itemIds)
6288 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
6292 
 
7265 rajveer 6293 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6294 
    args = updateStorePricing_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = updateStorePricing_result()
7382 rajveer 6298 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6299 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6300 
    result.write(oprot)
6301 
    oprot.writeMessageEnd()
6302 
    oprot.trans.flush()
7256 rajveer 6303 
 
7281 kshitij.so 6304 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6305 
    args = getAllAmazonListedItems_args()
6306 
    args.read(iprot)
6307 
    iprot.readMessageEnd()
6308 
    result = getAllAmazonListedItems_result()
6309 
    result.success = self._handler.getAllAmazonListedItems()
6310 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
7265 rajveer 6314 
 
8619 kshitij.so 6315 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6316 
    args = searchAmazonItems_args()
6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
6319 
    result = searchAmazonItems_result()
6320 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6321 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6322 
    result.write(oprot)
6323 
    oprot.writeMessageEnd()
6324 
    oprot.trans.flush()
6325 
 
6326 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6327 
    args = getAmazonSearchResultCount_args()
6328 
    args.read(iprot)
6329 
    iprot.readMessageEnd()
6330 
    result = getAmazonSearchResultCount_result()
6331 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6332 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
6336 
 
6337 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6338 
    args = getCountForAmazonlistedItems_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = getCountForAmazonlistedItems_result()
6342 
    result.success = self._handler.getCountForAmazonlistedItems()
6343 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
7281 kshitij.so 6348 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6349 
    args = getAmazonItemDetails_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = getAmazonItemDetails_result()
6353 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6354 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
6358 
 
6359 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6360 
    args = updateAmazonItemDetails_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6364 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6365 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6366 
    result.write(oprot)
6367 
    oprot.writeMessageEnd()
6368 
    oprot.trans.flush()
6369 
 
6370 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6371 
    args = addAmazonItem_args()
6372 
    args.read(iprot)
6373 
    iprot.readMessageEnd()
6374 
    result = addAmazonItem_result()
6375 
    self._handler.addAmazonItem(args.amazonlisted)
6376 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
6380 
 
7291 vikram.rag 6381 
  def process_getAsinItems(self, seqid, iprot, oprot):
6382 
    args = getAsinItems_args()
6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
6385 
    result = getAsinItems_result()
6386 
    result.success = self._handler.getAsinItems()
6387 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
7281 kshitij.so 6391 
 
7291 vikram.rag 6392 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6393 
    args = getAllFbaListedItems_args()
6394 
    args.read(iprot)
6395 
    iprot.readMessageEnd()
6396 
    result = getAllFbaListedItems_result()
6397 
    result.success = self._handler.getAllFbaListedItems()
6398 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6399 
    result.write(oprot)
6400 
    oprot.writeMessageEnd()
6401 
    oprot.trans.flush()
6402 
 
6403 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6404 
    args = getAllNonFbaListedItems_args()
6405 
    args.read(iprot)
6406 
    iprot.readMessageEnd()
6407 
    result = getAllNonFbaListedItems_result()
6408 
    result.success = self._handler.getAllNonFbaListedItems()
6409 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6410 
    result.write(oprot)
6411 
    oprot.writeMessageEnd()
6412 
    oprot.trans.flush()
6413 
 
7460 kshitij.so 6414 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6415 
    args = updateItemInventory_args()
6416 
    args.read(iprot)
6417 
    iprot.readMessageEnd()
6418 
    result = updateItemInventory_result()
6419 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6420 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6421 
    result.write(oprot)
6422 
    oprot.writeMessageEnd()
6423 
    oprot.trans.flush()
7291 vikram.rag 6424 
 
7770 kshitij.so 6425 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6426 
    args = updateTimestampForAmazonFeeds_args()
6427 
    args.read(iprot)
6428 
    iprot.readMessageEnd()
6429 
    result = updateTimestampForAmazonFeeds_result()
6430 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6431 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6432 
    result.write(oprot)
6433 
    oprot.writeMessageEnd()
6434 
    oprot.trans.flush()
7460 kshitij.so 6435 
 
7897 amar.kumar 6436 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6437 
    args = getAllParentCategories_args()
6438 
    args.read(iprot)
6439 
    iprot.readMessageEnd()
6440 
    result = getAllParentCategories_result()
6441 
    result.success = self._handler.getAllParentCategories()
6442 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6443 
    result.write(oprot)
6444 
    oprot.writeMessageEnd()
6445 
    oprot.trans.flush()
7770 kshitij.so 6446 
 
7977 kshitij.so 6447 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6448 
    args = addPageViewEvent_args()
6449 
    args.read(iprot)
6450 
    iprot.readMessageEnd()
6451 
    result = addPageViewEvent_result()
6452 
    self._handler.addPageViewEvent(args.pageViewEvents)
6453 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6454 
    result.write(oprot)
6455 
    oprot.writeMessageEnd()
6456 
    oprot.trans.flush()
7897 amar.kumar 6457 
 
7977 kshitij.so 6458 
  def process_addCartEvent(self, seqid, iprot, oprot):
6459 
    args = addCartEvent_args()
6460 
    args.read(iprot)
6461 
    iprot.readMessageEnd()
6462 
    result = addCartEvent_result()
6463 
    self._handler.addCartEvent(args.cartEvents)
6464 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6465 
    result.write(oprot)
6466 
    oprot.writeMessageEnd()
6467 
    oprot.trans.flush()
6468 
 
8182 amar.kumar 6469 
  def process_addEbayItem(self, seqid, iprot, oprot):
6470 
    args = addEbayItem_args()
6471 
    args.read(iprot)
6472 
    iprot.readMessageEnd()
6473 
    result = addEbayItem_result()
6474 
    self._handler.addEbayItem(args.ebayItem)
6475 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6476 
    result.write(oprot)
6477 
    oprot.writeMessageEnd()
6478 
    oprot.trans.flush()
6479 
 
6480 
  def process_getEbayItem(self, seqid, iprot, oprot):
6481 
    args = getEbayItem_args()
6482 
    args.read(iprot)
6483 
    iprot.readMessageEnd()
6484 
    result = getEbayItem_result()
6485 
    result.success = self._handler.getEbayItem(args.listingId)
6486 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6487 
    result.write(oprot)
6488 
    oprot.writeMessageEnd()
6489 
    oprot.trans.flush()
6490 
 
6491 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6492 
    args = updateEbayItem_args()
6493 
    args.read(iprot)
6494 
    iprot.readMessageEnd()
6495 
    result = updateEbayItem_result()
6496 
    self._handler.updateEbayItem(args.ebayItem)
6497 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6498 
    result.write(oprot)
6499 
    oprot.writeMessageEnd()
6500 
    oprot.trans.flush()
6501 
 
8139 kshitij.so 6502 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6503 
    args = getAmazonListedItems_args()
6504 
    args.read(iprot)
6505 
    iprot.readMessageEnd()
6506 
    result = getAmazonListedItems_result()
6507 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6508 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6509 
    result.write(oprot)
6510 
    oprot.writeMessageEnd()
6511 
    oprot.trans.flush()
7977 kshitij.so 6512 
 
8168 kshitij.so 6513 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6514 
    args = updateAmazonAttributesInBulk_args()
6515 
    args.read(iprot)
6516 
    iprot.readMessageEnd()
6517 
    result = updateAmazonAttributesInBulk_result()
6518 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6519 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6520 
    result.write(oprot)
6521 
    oprot.writeMessageEnd()
6522 
    oprot.trans.flush()
8139 kshitij.so 6523 
 
8379 vikram.rag 6524 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6525 
    args = getAllItemstoListOnFba_args()
6526 
    args.read(iprot)
6527 
    iprot.readMessageEnd()
6528 
    result = getAllItemstoListOnFba_result()
6529 
    result.success = self._handler.getAllItemstoListOnFba()
6530 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
8168 kshitij.so 6534 
 
8379 vikram.rag 6535 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6536 
    args = getAllItemstoListOnNonFba_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = getAllItemstoListOnNonFba_result()
6540 
    result.success = self._handler.getAllItemstoListOnNonFba()
6541 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6542 
    result.write(oprot)
6543 
    oprot.writeMessageEnd()
6544 
    oprot.trans.flush()
6545 
 
8619 kshitij.so 6546 
  def process_updateAsin(self, seqid, iprot, oprot):
6547 
    args = updateAsin_args()
6548 
    args.read(iprot)
6549 
    iprot.readMessageEnd()
6550 
    result = updateAsin_result()
6551 
    self._handler.updateAsin(args.item)
6552 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6553 
    result.write(oprot)
6554 
    oprot.writeMessageEnd()
6555 
    oprot.trans.flush()
8616 vikram.rag 6556 
 
8739 vikram.rag 6557 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6558 
    args = addOrUpdateSnapdealItem_args()
6559 
    args.read(iprot)
6560 
    iprot.readMessageEnd()
6561 
    result = addOrUpdateSnapdealItem_result()
6562 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6563 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6564 
    result.write(oprot)
6565 
    oprot.writeMessageEnd()
6566 
    oprot.trans.flush()
8619 kshitij.so 6567 
 
8739 vikram.rag 6568 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6569 
    args = getSnapdealItem_args()
6570 
    args.read(iprot)
6571 
    iprot.readMessageEnd()
6572 
    result = getSnapdealItem_result()
6573 
    result.success = self._handler.getSnapdealItem(args.item_id)
6574 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
9242 kshitij.so 6579 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
6580 
    args = getSnapdealItemDetails_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = getSnapdealItemDetails_result()
6584 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
6585 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
8739 vikram.rag 6590 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6591 
    args = getAllSnapdealItems_args()
6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
6594 
    result = getAllSnapdealItems_result()
6595 
    result.success = self._handler.getAllSnapdealItems()
6596 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
6600 
 
9242 kshitij.so 6601 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
6602 
    args = getSnapdealItems_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getSnapdealItems_result()
6606 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
6607 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
8739 vikram.rag 6611 
 
9242 kshitij.so 6612 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
6613 
    args = searchSnapdealItems_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = searchSnapdealItems_result()
6617 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
6618 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
6623 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
6624 
    args = getCountForSnapdealItems_args()
6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
6627 
    result = getCountForSnapdealItems_result()
6628 
    result.success = self._handler.getCountForSnapdealItems()
6629 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
6630 
    result.write(oprot)
6631 
    oprot.writeMessageEnd()
6632 
    oprot.trans.flush()
6633 
 
6634 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
6635 
    args = getSnapdealSearchResultCount_args()
6636 
    args.read(iprot)
6637 
    iprot.readMessageEnd()
6638 
    result = getSnapdealSearchResultCount_result()
6639 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
6640 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
6645 
 
5944 mandeep.dh 6646 
# HELPER FUNCTIONS AND STRUCTURES
6647 
 
6648 
class addItem_args:
6649 
  """
6650 
  Attributes:
6651 
   - item
6652 
  """
6653 
 
6654 
  thrift_spec = (
6655 
    None, # 0
6656 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6657 
  )
6658 
 
6659 
  def __init__(self, item=None,):
6660 
    self.item = item
6661 
 
6662 
  def read(self, iprot):
6663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6665 
      return
6666 
    iprot.readStructBegin()
6667 
    while True:
6668 
      (fname, ftype, fid) = iprot.readFieldBegin()
6669 
      if ftype == TType.STOP:
6670 
        break
6671 
      if fid == 1:
6672 
        if ftype == TType.STRUCT:
6673 
          self.item = Item()
6674 
          self.item.read(iprot)
6675 
        else:
6676 
          iprot.skip(ftype)
6677 
      else:
6678 
        iprot.skip(ftype)
6679 
      iprot.readFieldEnd()
6680 
    iprot.readStructEnd()
6681 
 
6682 
  def write(self, oprot):
6683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6685 
      return
6686 
    oprot.writeStructBegin('addItem_args')
6687 
    if self.item is not None:
6688 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6689 
      self.item.write(oprot)
6690 
      oprot.writeFieldEnd()
6691 
    oprot.writeFieldStop()
6692 
    oprot.writeStructEnd()
6693 
 
6694 
  def validate(self):
6695 
    return
6696 
 
6697 
 
6698 
  def __repr__(self):
6699 
    L = ['%s=%r' % (key, value)
6700 
      for key, value in self.__dict__.iteritems()]
6701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6702 
 
6703 
  def __eq__(self, other):
6704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6705 
 
6706 
  def __ne__(self, other):
6707 
    return not (self == other)
6708 
 
6709 
class addItem_result:
6710 
  """
6711 
  Attributes:
6712 
   - success
6713 
   - cex
6714 
  """
6715 
 
6716 
  thrift_spec = (
6717 
    (0, TType.I64, 'success', None, None, ), # 0
6718 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6719 
  )
6720 
 
6721 
  def __init__(self, success=None, cex=None,):
6722 
    self.success = success
6723 
    self.cex = cex
6724 
 
6725 
  def read(self, iprot):
6726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6728 
      return
6729 
    iprot.readStructBegin()
6730 
    while True:
6731 
      (fname, ftype, fid) = iprot.readFieldBegin()
6732 
      if ftype == TType.STOP:
6733 
        break
6734 
      if fid == 0:
6735 
        if ftype == TType.I64:
6736 
          self.success = iprot.readI64();
6737 
        else:
6738 
          iprot.skip(ftype)
6739 
      elif fid == 1:
6740 
        if ftype == TType.STRUCT:
6741 
          self.cex = CatalogServiceException()
6742 
          self.cex.read(iprot)
6743 
        else:
6744 
          iprot.skip(ftype)
6745 
      else:
6746 
        iprot.skip(ftype)
6747 
      iprot.readFieldEnd()
6748 
    iprot.readStructEnd()
6749 
 
6750 
  def write(self, oprot):
6751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6753 
      return
6754 
    oprot.writeStructBegin('addItem_result')
6755 
    if self.success is not None:
6756 
      oprot.writeFieldBegin('success', TType.I64, 0)
6757 
      oprot.writeI64(self.success)
6758 
      oprot.writeFieldEnd()
6759 
    if self.cex is not None:
6760 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6761 
      self.cex.write(oprot)
6762 
      oprot.writeFieldEnd()
6763 
    oprot.writeFieldStop()
6764 
    oprot.writeStructEnd()
6765 
 
6766 
  def validate(self):
6767 
    return
6768 
 
6769 
 
6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
6781 
class updateItem_args:
6782 
  """
6783 
  Attributes:
6784 
   - item
6785 
  """
6786 
 
6787 
  thrift_spec = (
6788 
    None, # 0
6789 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6790 
  )
6791 
 
6792 
  def __init__(self, item=None,):
6793 
    self.item = item
6794 
 
6795 
  def read(self, iprot):
6796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6798 
      return
6799 
    iprot.readStructBegin()
6800 
    while True:
6801 
      (fname, ftype, fid) = iprot.readFieldBegin()
6802 
      if ftype == TType.STOP:
6803 
        break
6804 
      if fid == 1:
6805 
        if ftype == TType.STRUCT:
6806 
          self.item = Item()
6807 
          self.item.read(iprot)
6808 
        else:
6809 
          iprot.skip(ftype)
6810 
      else:
6811 
        iprot.skip(ftype)
6812 
      iprot.readFieldEnd()
6813 
    iprot.readStructEnd()
6814 
 
6815 
  def write(self, oprot):
6816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6818 
      return
6819 
    oprot.writeStructBegin('updateItem_args')
6820 
    if self.item is not None:
6821 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6822 
      self.item.write(oprot)
6823 
      oprot.writeFieldEnd()
6824 
    oprot.writeFieldStop()
6825 
    oprot.writeStructEnd()
6826 
 
6827 
  def validate(self):
6828 
    return
6829 
 
6830 
 
6831 
  def __repr__(self):
6832 
    L = ['%s=%r' % (key, value)
6833 
      for key, value in self.__dict__.iteritems()]
6834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6835 
 
6836 
  def __eq__(self, other):
6837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6838 
 
6839 
  def __ne__(self, other):
6840 
    return not (self == other)
6841 
 
6842 
class updateItem_result:
6843 
  """
6844 
  Attributes:
6845 
   - success
6846 
   - cex
6847 
  """
6848 
 
6849 
  thrift_spec = (
6850 
    (0, TType.I64, 'success', None, None, ), # 0
6851 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6852 
  )
6853 
 
6854 
  def __init__(self, success=None, cex=None,):
6855 
    self.success = success
6856 
    self.cex = cex
6857 
 
6858 
  def read(self, iprot):
6859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6861 
      return
6862 
    iprot.readStructBegin()
6863 
    while True:
6864 
      (fname, ftype, fid) = iprot.readFieldBegin()
6865 
      if ftype == TType.STOP:
6866 
        break
6867 
      if fid == 0:
6868 
        if ftype == TType.I64:
6869 
          self.success = iprot.readI64();
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      elif fid == 1:
6873 
        if ftype == TType.STRUCT:
6874 
          self.cex = CatalogServiceException()
6875 
          self.cex.read(iprot)
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      else:
6879 
        iprot.skip(ftype)
6880 
      iprot.readFieldEnd()
6881 
    iprot.readStructEnd()
6882 
 
6883 
  def write(self, oprot):
6884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6886 
      return
6887 
    oprot.writeStructBegin('updateItem_result')
6888 
    if self.success is not None:
6889 
      oprot.writeFieldBegin('success', TType.I64, 0)
6890 
      oprot.writeI64(self.success)
6891 
      oprot.writeFieldEnd()
6892 
    if self.cex is not None:
6893 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6894 
      self.cex.write(oprot)
6895 
      oprot.writeFieldEnd()
6896 
    oprot.writeFieldStop()
6897 
    oprot.writeStructEnd()
6898 
 
6899 
  def validate(self):
6900 
    return
6901 
 
6902 
 
6903 
  def __repr__(self):
6904 
    L = ['%s=%r' % (key, value)
6905 
      for key, value in self.__dict__.iteritems()]
6906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6907 
 
6908 
  def __eq__(self, other):
6909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6910 
 
6911 
  def __ne__(self, other):
6912 
    return not (self == other)
6913 
 
6914 
class isActive_args:
6915 
  """
6916 
  Attributes:
6917 
   - itemId
6918 
  """
6919 
 
6920 
  thrift_spec = (
6921 
    None, # 0
6922 
    (1, TType.I64, 'itemId', None, None, ), # 1
6923 
  )
6924 
 
6925 
  def __init__(self, itemId=None,):
6926 
    self.itemId = itemId
6927 
 
6928 
  def read(self, iprot):
6929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6931 
      return
6932 
    iprot.readStructBegin()
6933 
    while True:
6934 
      (fname, ftype, fid) = iprot.readFieldBegin()
6935 
      if ftype == TType.STOP:
6936 
        break
6937 
      if fid == 1:
6938 
        if ftype == TType.I64:
6939 
          self.itemId = iprot.readI64();
6940 
        else:
6941 
          iprot.skip(ftype)
6942 
      else:
6943 
        iprot.skip(ftype)
6944 
      iprot.readFieldEnd()
6945 
    iprot.readStructEnd()
6946 
 
6947 
  def write(self, oprot):
6948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6950 
      return
6951 
    oprot.writeStructBegin('isActive_args')
6952 
    if self.itemId is not None:
6953 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6954 
      oprot.writeI64(self.itemId)
6955 
      oprot.writeFieldEnd()
6956 
    oprot.writeFieldStop()
6957 
    oprot.writeStructEnd()
6958 
 
6959 
  def validate(self):
6960 
    return
6961 
 
6962 
 
6963 
  def __repr__(self):
6964 
    L = ['%s=%r' % (key, value)
6965 
      for key, value in self.__dict__.iteritems()]
6966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6967 
 
6968 
  def __eq__(self, other):
6969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6970 
 
6971 
  def __ne__(self, other):
6972 
    return not (self == other)
6973 
 
6974 
class isActive_result:
6975 
  """
6976 
  Attributes:
6977 
   - success
6978 
   - isex
6979 
  """
6980 
 
6981 
  thrift_spec = (
6982 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6983 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6984 
  )
6985 
 
6986 
  def __init__(self, success=None, isex=None,):
6987 
    self.success = success
6988 
    self.isex = isex
6989 
 
6990 
  def read(self, iprot):
6991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6993 
      return
6994 
    iprot.readStructBegin()
6995 
    while True:
6996 
      (fname, ftype, fid) = iprot.readFieldBegin()
6997 
      if ftype == TType.STOP:
6998 
        break
6999 
      if fid == 0:
7000 
        if ftype == TType.STRUCT:
7001 
          self.success = ItemShippingInfo()
7002 
          self.success.read(iprot)
7003 
        else:
7004 
          iprot.skip(ftype)
7005 
      elif fid == 1:
7006 
        if ftype == TType.STRUCT:
7007 
          self.isex = CatalogServiceException()
7008 
          self.isex.read(iprot)
7009 
        else:
7010 
          iprot.skip(ftype)
7011 
      else:
7012 
        iprot.skip(ftype)
7013 
      iprot.readFieldEnd()
7014 
    iprot.readStructEnd()
7015 
 
7016 
  def write(self, oprot):
7017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7019 
      return
7020 
    oprot.writeStructBegin('isActive_result')
7021 
    if self.success is not None:
7022 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7023 
      self.success.write(oprot)
7024 
      oprot.writeFieldEnd()
7025 
    if self.isex is not None:
7026 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7027 
      self.isex.write(oprot)
7028 
      oprot.writeFieldEnd()
7029 
    oprot.writeFieldStop()
7030 
    oprot.writeStructEnd()
7031 
 
7032 
  def validate(self):
7033 
    return
7034 
 
7035 
 
7036 
  def __repr__(self):
7037 
    L = ['%s=%r' % (key, value)
7038 
      for key, value in self.__dict__.iteritems()]
7039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7040 
 
7041 
  def __eq__(self, other):
7042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7043 
 
7044 
  def __ne__(self, other):
7045 
    return not (self == other)
7046 
 
7438 amit.gupta 7047 
class getItemsStatus_args:
7048 
  """
7049 
  Attributes:
7050 
   - itemIds
7051 
  """
7052 
 
7053 
  thrift_spec = (
7054 
    None, # 0
7055 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7056 
  )
7057 
 
7058 
  def __init__(self, itemIds=None,):
7059 
    self.itemIds = itemIds
7060 
 
7061 
  def read(self, iprot):
7062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7064 
      return
7065 
    iprot.readStructBegin()
7066 
    while True:
7067 
      (fname, ftype, fid) = iprot.readFieldBegin()
7068 
      if ftype == TType.STOP:
7069 
        break
7070 
      if fid == 1:
7071 
        if ftype == TType.LIST:
7072 
          self.itemIds = []
8590 kshitij.so 7073 
          (_etype33, _size30) = iprot.readListBegin()
7074 
          for _i34 in xrange(_size30):
7075 
            _elem35 = iprot.readI64();
7076 
            self.itemIds.append(_elem35)
7438 amit.gupta 7077 
          iprot.readListEnd()
7078 
        else:
7079 
          iprot.skip(ftype)
7080 
      else:
7081 
        iprot.skip(ftype)
7082 
      iprot.readFieldEnd()
7083 
    iprot.readStructEnd()
7084 
 
7085 
  def write(self, oprot):
7086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7088 
      return
7089 
    oprot.writeStructBegin('getItemsStatus_args')
7090 
    if self.itemIds is not None:
7091 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7092 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7093 
      for iter36 in self.itemIds:
7094 
        oprot.writeI64(iter36)
7438 amit.gupta 7095 
      oprot.writeListEnd()
7096 
      oprot.writeFieldEnd()
7097 
    oprot.writeFieldStop()
7098 
    oprot.writeStructEnd()
7099 
 
7100 
  def validate(self):
7101 
    return
7102 
 
7103 
 
7104 
  def __repr__(self):
7105 
    L = ['%s=%r' % (key, value)
7106 
      for key, value in self.__dict__.iteritems()]
7107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7108 
 
7109 
  def __eq__(self, other):
7110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7111 
 
7112 
  def __ne__(self, other):
7113 
    return not (self == other)
7114 
 
7115 
class getItemsStatus_result:
7116 
  """
7117 
  Attributes:
7118 
   - success
7119 
   - isex
7120 
  """
7121 
 
7122 
  thrift_spec = (
7123 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7124 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7125 
  )
7126 
 
7127 
  def __init__(self, success=None, isex=None,):
7128 
    self.success = success
7129 
    self.isex = isex
7130 
 
7131 
  def read(self, iprot):
7132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7134 
      return
7135 
    iprot.readStructBegin()
7136 
    while True:
7137 
      (fname, ftype, fid) = iprot.readFieldBegin()
7138 
      if ftype == TType.STOP:
7139 
        break
7140 
      if fid == 0:
7141 
        if ftype == TType.MAP:
7142 
          self.success = {}
8590 kshitij.so 7143 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7144 
          for _i41 in xrange(_size37):
7145 
            _key42 = iprot.readI64();
7146 
            _val43 = iprot.readBool();
7147 
            self.success[_key42] = _val43
7438 amit.gupta 7148 
          iprot.readMapEnd()
7149 
        else:
7150 
          iprot.skip(ftype)
7151 
      elif fid == 1:
7152 
        if ftype == TType.STRUCT:
7153 
          self.isex = CatalogServiceException()
7154 
          self.isex.read(iprot)
7155 
        else:
7156 
          iprot.skip(ftype)
7157 
      else:
7158 
        iprot.skip(ftype)
7159 
      iprot.readFieldEnd()
7160 
    iprot.readStructEnd()
7161 
 
7162 
  def write(self, oprot):
7163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7165 
      return
7166 
    oprot.writeStructBegin('getItemsStatus_result')
7167 
    if self.success is not None:
7168 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7169 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7170 
      for kiter44,viter45 in self.success.items():
7171 
        oprot.writeI64(kiter44)
7172 
        oprot.writeBool(viter45)
7438 amit.gupta 7173 
      oprot.writeMapEnd()
7174 
      oprot.writeFieldEnd()
7175 
    if self.isex is not None:
7176 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7177 
      self.isex.write(oprot)
7178 
      oprot.writeFieldEnd()
7179 
    oprot.writeFieldStop()
7180 
    oprot.writeStructEnd()
7181 
 
7182 
  def validate(self):
7183 
    return
7184 
 
7185 
 
7186 
  def __repr__(self):
7187 
    L = ['%s=%r' % (key, value)
7188 
      for key, value in self.__dict__.iteritems()]
7189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7190 
 
7191 
  def __eq__(self, other):
7192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7193 
 
7194 
  def __ne__(self, other):
7195 
    return not (self == other)
7196 
 
5944 mandeep.dh 7197 
class getItemStatusDescription_args:
7198 
  """
7199 
  Attributes:
7200 
   - itemId
7201 
  """
7202 
 
7203 
  thrift_spec = (
7204 
    None, # 0
7205 
    (1, TType.I64, 'itemId', None, None, ), # 1
7206 
  )
7207 
 
7208 
  def __init__(self, itemId=None,):
7209 
    self.itemId = itemId
7210 
 
7211 
  def read(self, iprot):
7212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7214 
      return
7215 
    iprot.readStructBegin()
7216 
    while True:
7217 
      (fname, ftype, fid) = iprot.readFieldBegin()
7218 
      if ftype == TType.STOP:
7219 
        break
7220 
      if fid == 1:
7221 
        if ftype == TType.I64:
7222 
          self.itemId = iprot.readI64();
7223 
        else:
7224 
          iprot.skip(ftype)
7225 
      else:
7226 
        iprot.skip(ftype)
7227 
      iprot.readFieldEnd()
7228 
    iprot.readStructEnd()
7229 
 
7230 
  def write(self, oprot):
7231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7233 
      return
7234 
    oprot.writeStructBegin('getItemStatusDescription_args')
7235 
    if self.itemId is not None:
7236 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7237 
      oprot.writeI64(self.itemId)
7238 
      oprot.writeFieldEnd()
7239 
    oprot.writeFieldStop()
7240 
    oprot.writeStructEnd()
7241 
 
7242 
  def validate(self):
7243 
    return
7244 
 
7245 
 
7246 
  def __repr__(self):
7247 
    L = ['%s=%r' % (key, value)
7248 
      for key, value in self.__dict__.iteritems()]
7249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7250 
 
7251 
  def __eq__(self, other):
7252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7253 
 
7254 
  def __ne__(self, other):
7255 
    return not (self == other)
7256 
 
7257 
class getItemStatusDescription_result:
7258 
  """
7259 
  Attributes:
7260 
   - success
7261 
   - isex
7262 
  """
7263 
 
7264 
  thrift_spec = (
7265 
    (0, TType.STRING, 'success', None, None, ), # 0
7266 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7267 
  )
7268 
 
7269 
  def __init__(self, success=None, isex=None,):
7270 
    self.success = success
7271 
    self.isex = isex
7272 
 
7273 
  def read(self, iprot):
7274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7276 
      return
7277 
    iprot.readStructBegin()
7278 
    while True:
7279 
      (fname, ftype, fid) = iprot.readFieldBegin()
7280 
      if ftype == TType.STOP:
7281 
        break
7282 
      if fid == 0:
7283 
        if ftype == TType.STRING:
7284 
          self.success = iprot.readString();
7285 
        else:
7286 
          iprot.skip(ftype)
7287 
      elif fid == 1:
7288 
        if ftype == TType.STRUCT:
7289 
          self.isex = CatalogServiceException()
7290 
          self.isex.read(iprot)
7291 
        else:
7292 
          iprot.skip(ftype)
7293 
      else:
7294 
        iprot.skip(ftype)
7295 
      iprot.readFieldEnd()
7296 
    iprot.readStructEnd()
7297 
 
7298 
  def write(self, oprot):
7299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7301 
      return
7302 
    oprot.writeStructBegin('getItemStatusDescription_result')
7303 
    if self.success is not None:
7304 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7305 
      oprot.writeString(self.success)
7306 
      oprot.writeFieldEnd()
7307 
    if self.isex is not None:
7308 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7309 
      self.isex.write(oprot)
7310 
      oprot.writeFieldEnd()
7311 
    oprot.writeFieldStop()
7312 
    oprot.writeStructEnd()
7313 
 
7314 
  def validate(self):
7315 
    return
7316 
 
7317 
 
7318 
  def __repr__(self):
7319 
    L = ['%s=%r' % (key, value)
7320 
      for key, value in self.__dict__.iteritems()]
7321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7322 
 
7323 
  def __eq__(self, other):
7324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7325 
 
7326 
  def __ne__(self, other):
7327 
    return not (self == other)
7328 
 
7329 
class startItemOn_args:
7330 
  """
7331 
  Attributes:
7332 
   - item_id
7333 
   - timestamp
7334 
  """
7335 
 
7336 
  thrift_spec = (
7337 
    None, # 0
7338 
    (1, TType.I64, 'item_id', None, None, ), # 1
7339 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7340 
  )
7341 
 
7342 
  def __init__(self, item_id=None, timestamp=None,):
7343 
    self.item_id = item_id
7344 
    self.timestamp = timestamp
7345 
 
7346 
  def read(self, iprot):
7347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7349 
      return
7350 
    iprot.readStructBegin()
7351 
    while True:
7352 
      (fname, ftype, fid) = iprot.readFieldBegin()
7353 
      if ftype == TType.STOP:
7354 
        break
7355 
      if fid == 1:
7356 
        if ftype == TType.I64:
7357 
          self.item_id = iprot.readI64();
7358 
        else:
7359 
          iprot.skip(ftype)
7360 
      elif fid == 2:
7361 
        if ftype == TType.I64:
7362 
          self.timestamp = iprot.readI64();
7363 
        else:
7364 
          iprot.skip(ftype)
7365 
      else:
7366 
        iprot.skip(ftype)
7367 
      iprot.readFieldEnd()
7368 
    iprot.readStructEnd()
7369 
 
7370 
  def write(self, oprot):
7371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7373 
      return
7374 
    oprot.writeStructBegin('startItemOn_args')
7375 
    if self.item_id is not None:
7376 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7377 
      oprot.writeI64(self.item_id)
7378 
      oprot.writeFieldEnd()
7379 
    if self.timestamp is not None:
7380 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7381 
      oprot.writeI64(self.timestamp)
7382 
      oprot.writeFieldEnd()
7383 
    oprot.writeFieldStop()
7384 
    oprot.writeStructEnd()
7385 
 
7386 
  def validate(self):
7387 
    return
7388 
 
7389 
 
7390 
  def __repr__(self):
7391 
    L = ['%s=%r' % (key, value)
7392 
      for key, value in self.__dict__.iteritems()]
7393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7394 
 
7395 
  def __eq__(self, other):
7396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7397 
 
7398 
  def __ne__(self, other):
7399 
    return not (self == other)
7400 
 
7401 
class startItemOn_result:
7402 
  """
7403 
  Attributes:
7404 
   - cex
7405 
  """
7406 
 
7407 
  thrift_spec = (
7408 
    None, # 0
7409 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7410 
  )
7411 
 
7412 
  def __init__(self, cex=None,):
7413 
    self.cex = cex
7414 
 
7415 
  def read(self, iprot):
7416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7418 
      return
7419 
    iprot.readStructBegin()
7420 
    while True:
7421 
      (fname, ftype, fid) = iprot.readFieldBegin()
7422 
      if ftype == TType.STOP:
7423 
        break
7424 
      if fid == 1:
7425 
        if ftype == TType.STRUCT:
7426 
          self.cex = CatalogServiceException()
7427 
          self.cex.read(iprot)
7428 
        else:
7429 
          iprot.skip(ftype)
7430 
      else:
7431 
        iprot.skip(ftype)
7432 
      iprot.readFieldEnd()
7433 
    iprot.readStructEnd()
7434 
 
7435 
  def write(self, oprot):
7436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7438 
      return
7439 
    oprot.writeStructBegin('startItemOn_result')
7440 
    if self.cex is not None:
7441 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7442 
      self.cex.write(oprot)
7443 
      oprot.writeFieldEnd()
7444 
    oprot.writeFieldStop()
7445 
    oprot.writeStructEnd()
7446 
 
7447 
  def validate(self):
7448 
    return
7449 
 
7450 
 
7451 
  def __repr__(self):
7452 
    L = ['%s=%r' % (key, value)
7453 
      for key, value in self.__dict__.iteritems()]
7454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7455 
 
7456 
  def __eq__(self, other):
7457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7458 
 
7459 
  def __ne__(self, other):
7460 
    return not (self == other)
7461 
 
7462 
class retireItemOn_args:
7463 
  """
7464 
  Attributes:
7465 
   - item_id
7466 
   - timestamp
7467 
  """
7468 
 
7469 
  thrift_spec = (
7470 
    None, # 0
7471 
    (1, TType.I64, 'item_id', None, None, ), # 1
7472 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7473 
  )
7474 
 
7475 
  def __init__(self, item_id=None, timestamp=None,):
7476 
    self.item_id = item_id
7477 
    self.timestamp = timestamp
7478 
 
7479 
  def read(self, iprot):
7480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7482 
      return
7483 
    iprot.readStructBegin()
7484 
    while True:
7485 
      (fname, ftype, fid) = iprot.readFieldBegin()
7486 
      if ftype == TType.STOP:
7487 
        break
7488 
      if fid == 1:
7489 
        if ftype == TType.I64:
7490 
          self.item_id = iprot.readI64();
7491 
        else:
7492 
          iprot.skip(ftype)
7493 
      elif fid == 2:
7494 
        if ftype == TType.I64:
7495 
          self.timestamp = iprot.readI64();
7496 
        else:
7497 
          iprot.skip(ftype)
7498 
      else:
7499 
        iprot.skip(ftype)
7500 
      iprot.readFieldEnd()
7501 
    iprot.readStructEnd()
7502 
 
7503 
  def write(self, oprot):
7504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7506 
      return
7507 
    oprot.writeStructBegin('retireItemOn_args')
7508 
    if self.item_id is not None:
7509 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7510 
      oprot.writeI64(self.item_id)
7511 
      oprot.writeFieldEnd()
7512 
    if self.timestamp is not None:
7513 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7514 
      oprot.writeI64(self.timestamp)
7515 
      oprot.writeFieldEnd()
7516 
    oprot.writeFieldStop()
7517 
    oprot.writeStructEnd()
7518 
 
7519 
  def validate(self):
7520 
    return
7521 
 
7522 
 
7523 
  def __repr__(self):
7524 
    L = ['%s=%r' % (key, value)
7525 
      for key, value in self.__dict__.iteritems()]
7526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7527 
 
7528 
  def __eq__(self, other):
7529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7530 
 
7531 
  def __ne__(self, other):
7532 
    return not (self == other)
7533 
 
7534 
class retireItemOn_result:
7535 
  """
7536 
  Attributes:
7537 
   - cex
7538 
  """
7539 
 
7540 
  thrift_spec = (
7541 
    None, # 0
7542 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7543 
  )
7544 
 
7545 
  def __init__(self, cex=None,):
7546 
    self.cex = cex
7547 
 
7548 
  def read(self, iprot):
7549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7551 
      return
7552 
    iprot.readStructBegin()
7553 
    while True:
7554 
      (fname, ftype, fid) = iprot.readFieldBegin()
7555 
      if ftype == TType.STOP:
7556 
        break
7557 
      if fid == 1:
7558 
        if ftype == TType.STRUCT:
7559 
          self.cex = CatalogServiceException()
7560 
          self.cex.read(iprot)
7561 
        else:
7562 
          iprot.skip(ftype)
7563 
      else:
7564 
        iprot.skip(ftype)
7565 
      iprot.readFieldEnd()
7566 
    iprot.readStructEnd()
7567 
 
7568 
  def write(self, oprot):
7569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7571 
      return
7572 
    oprot.writeStructBegin('retireItemOn_result')
7573 
    if self.cex is not None:
7574 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7575 
      self.cex.write(oprot)
7576 
      oprot.writeFieldEnd()
7577 
    oprot.writeFieldStop()
7578 
    oprot.writeStructEnd()
7579 
 
7580 
  def validate(self):
7581 
    return
7582 
 
7583 
 
7584 
  def __repr__(self):
7585 
    L = ['%s=%r' % (key, value)
7586 
      for key, value in self.__dict__.iteritems()]
7587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7588 
 
7589 
  def __eq__(self, other):
7590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7591 
 
7592 
  def __ne__(self, other):
7593 
    return not (self == other)
7594 
 
7595 
class changeItemStatus_args:
7596 
  """
7597 
  Attributes:
7598 
   - item_id
7599 
   - timestamp
7600 
   - newstatus
7601 
  """
7602 
 
7603 
  thrift_spec = (
7604 
    None, # 0
7605 
    (1, TType.I64, 'item_id', None, None, ), # 1
7606 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7607 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7608 
  )
7609 
 
7610 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7611 
    self.item_id = item_id
7612 
    self.timestamp = timestamp
7613 
    self.newstatus = newstatus
7614 
 
7615 
  def read(self, iprot):
7616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7618 
      return
7619 
    iprot.readStructBegin()
7620 
    while True:
7621 
      (fname, ftype, fid) = iprot.readFieldBegin()
7622 
      if ftype == TType.STOP:
7623 
        break
7624 
      if fid == 1:
7625 
        if ftype == TType.I64:
7626 
          self.item_id = iprot.readI64();
7627 
        else:
7628 
          iprot.skip(ftype)
7629 
      elif fid == 2:
7630 
        if ftype == TType.I64:
7631 
          self.timestamp = iprot.readI64();
7632 
        else:
7633 
          iprot.skip(ftype)
7634 
      elif fid == 3:
7635 
        if ftype == TType.I32:
7636 
          self.newstatus = iprot.readI32();
7637 
        else:
7638 
          iprot.skip(ftype)
7639 
      else:
7640 
        iprot.skip(ftype)
7641 
      iprot.readFieldEnd()
7642 
    iprot.readStructEnd()
7643 
 
7644 
  def write(self, oprot):
7645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7647 
      return
7648 
    oprot.writeStructBegin('changeItemStatus_args')
7649 
    if self.item_id is not None:
7650 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7651 
      oprot.writeI64(self.item_id)
7652 
      oprot.writeFieldEnd()
7653 
    if self.timestamp is not None:
7654 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7655 
      oprot.writeI64(self.timestamp)
7656 
      oprot.writeFieldEnd()
7657 
    if self.newstatus is not None:
7658 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7659 
      oprot.writeI32(self.newstatus)
7660 
      oprot.writeFieldEnd()
7661 
    oprot.writeFieldStop()
7662 
    oprot.writeStructEnd()
7663 
 
7664 
  def validate(self):
7665 
    return
7666 
 
7667 
 
7668 
  def __repr__(self):
7669 
    L = ['%s=%r' % (key, value)
7670 
      for key, value in self.__dict__.iteritems()]
7671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7672 
 
7673 
  def __eq__(self, other):
7674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7675 
 
7676 
  def __ne__(self, other):
7677 
    return not (self == other)
7678 
 
7679 
class changeItemStatus_result:
7680 
  """
7681 
  Attributes:
7682 
   - cex
7683 
  """
7684 
 
7685 
  thrift_spec = (
7686 
    None, # 0
7687 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7688 
  )
7689 
 
7690 
  def __init__(self, cex=None,):
7691 
    self.cex = cex
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 == 1:
7703 
        if ftype == TType.STRUCT:
7704 
          self.cex = CatalogServiceException()
7705 
          self.cex.read(iprot)
7706 
        else:
7707 
          iprot.skip(ftype)
7708 
      else:
7709 
        iprot.skip(ftype)
7710 
      iprot.readFieldEnd()
7711 
    iprot.readStructEnd()
7712 
 
7713 
  def write(self, oprot):
7714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7716 
      return
7717 
    oprot.writeStructBegin('changeItemStatus_result')
7718 
    if self.cex is not None:
7719 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7720 
      self.cex.write(oprot)
7721 
      oprot.writeFieldEnd()
7722 
    oprot.writeFieldStop()
7723 
    oprot.writeStructEnd()
7724 
 
7725 
  def validate(self):
7726 
    return
7727 
 
7728 
 
7729 
  def __repr__(self):
7730 
    L = ['%s=%r' % (key, value)
7731 
      for key, value in self.__dict__.iteritems()]
7732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7733 
 
7734 
  def __eq__(self, other):
7735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7736 
 
7737 
  def __ne__(self, other):
7738 
    return not (self == other)
7739 
 
7740 
class getItem_args:
7741 
  """
7742 
  Attributes:
7743 
   - item_id
7744 
  """
7745 
 
7746 
  thrift_spec = (
7747 
    None, # 0
7748 
    (1, TType.I64, 'item_id', None, None, ), # 1
7749 
  )
7750 
 
7751 
  def __init__(self, item_id=None,):
7752 
    self.item_id = item_id
7753 
 
7754 
  def read(self, iprot):
7755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7757 
      return
7758 
    iprot.readStructBegin()
7759 
    while True:
7760 
      (fname, ftype, fid) = iprot.readFieldBegin()
7761 
      if ftype == TType.STOP:
7762 
        break
7763 
      if fid == 1:
7764 
        if ftype == TType.I64:
7765 
          self.item_id = iprot.readI64();
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      else:
7769 
        iprot.skip(ftype)
7770 
      iprot.readFieldEnd()
7771 
    iprot.readStructEnd()
7772 
 
7773 
  def write(self, oprot):
7774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7776 
      return
7777 
    oprot.writeStructBegin('getItem_args')
7778 
    if self.item_id is not None:
7779 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7780 
      oprot.writeI64(self.item_id)
7781 
      oprot.writeFieldEnd()
7782 
    oprot.writeFieldStop()
7783 
    oprot.writeStructEnd()
7784 
 
7785 
  def validate(self):
7786 
    return
7787 
 
7788 
 
7789 
  def __repr__(self):
7790 
    L = ['%s=%r' % (key, value)
7791 
      for key, value in self.__dict__.iteritems()]
7792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7793 
 
7794 
  def __eq__(self, other):
7795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7796 
 
7797 
  def __ne__(self, other):
7798 
    return not (self == other)
7799 
 
7800 
class getItem_result:
7801 
  """
7802 
  Attributes:
7803 
   - success
7804 
   - cex
7805 
  """
7806 
 
7807 
  thrift_spec = (
7808 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7809 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7810 
  )
7811 
 
7812 
  def __init__(self, success=None, cex=None,):
7813 
    self.success = success
7814 
    self.cex = cex
7815 
 
7816 
  def read(self, iprot):
7817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7819 
      return
7820 
    iprot.readStructBegin()
7821 
    while True:
7822 
      (fname, ftype, fid) = iprot.readFieldBegin()
7823 
      if ftype == TType.STOP:
7824 
        break
7825 
      if fid == 0:
7826 
        if ftype == TType.STRUCT:
7827 
          self.success = Item()
7828 
          self.success.read(iprot)
7829 
        else:
7830 
          iprot.skip(ftype)
7831 
      elif fid == 1:
7832 
        if ftype == TType.STRUCT:
7833 
          self.cex = CatalogServiceException()
7834 
          self.cex.read(iprot)
7835 
        else:
7836 
          iprot.skip(ftype)
7837 
      else:
7838 
        iprot.skip(ftype)
7839 
      iprot.readFieldEnd()
7840 
    iprot.readStructEnd()
7841 
 
7842 
  def write(self, oprot):
7843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7845 
      return
7846 
    oprot.writeStructBegin('getItem_result')
7847 
    if self.success is not None:
7848 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7849 
      self.success.write(oprot)
7850 
      oprot.writeFieldEnd()
7851 
    if self.cex is not None:
7852 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7853 
      self.cex.write(oprot)
7854 
      oprot.writeFieldEnd()
7855 
    oprot.writeFieldStop()
7856 
    oprot.writeStructEnd()
7857 
 
7858 
  def validate(self):
7859 
    return
7860 
 
7861 
 
7862 
  def __repr__(self):
7863 
    L = ['%s=%r' % (key, value)
7864 
      for key, value in self.__dict__.iteritems()]
7865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7866 
 
7867 
  def __eq__(self, other):
7868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7869 
 
7870 
  def __ne__(self, other):
7871 
    return not (self == other)
7872 
 
7873 
class getItemsByCatalogId_args:
7874 
  """
7875 
  Attributes:
7876 
   - catalog_item_id
7877 
  """
7878 
 
7879 
  thrift_spec = (
7880 
    None, # 0
7881 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7882 
  )
7883 
 
7884 
  def __init__(self, catalog_item_id=None,):
7885 
    self.catalog_item_id = catalog_item_id
7886 
 
7887 
  def read(self, iprot):
7888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7890 
      return
7891 
    iprot.readStructBegin()
7892 
    while True:
7893 
      (fname, ftype, fid) = iprot.readFieldBegin()
7894 
      if ftype == TType.STOP:
7895 
        break
7896 
      if fid == 1:
7897 
        if ftype == TType.I64:
7898 
          self.catalog_item_id = iprot.readI64();
7899 
        else:
7900 
          iprot.skip(ftype)
7901 
      else:
7902 
        iprot.skip(ftype)
7903 
      iprot.readFieldEnd()
7904 
    iprot.readStructEnd()
7905 
 
7906 
  def write(self, oprot):
7907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7909 
      return
7910 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7911 
    if self.catalog_item_id is not None:
7912 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7913 
      oprot.writeI64(self.catalog_item_id)
7914 
      oprot.writeFieldEnd()
7915 
    oprot.writeFieldStop()
7916 
    oprot.writeStructEnd()
7917 
 
7918 
  def validate(self):
7919 
    return
7920 
 
7921 
 
7922 
  def __repr__(self):
7923 
    L = ['%s=%r' % (key, value)
7924 
      for key, value in self.__dict__.iteritems()]
7925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7926 
 
7927 
  def __eq__(self, other):
7928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7929 
 
7930 
  def __ne__(self, other):
7931 
    return not (self == other)
7932 
 
7933 
class getItemsByCatalogId_result:
7934 
  """
7935 
  Attributes:
7936 
   - success
7937 
   - cex
7938 
  """
7939 
 
7940 
  thrift_spec = (
7941 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7942 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7943 
  )
7944 
 
7945 
  def __init__(self, success=None, cex=None,):
7946 
    self.success = success
7947 
    self.cex = cex
7948 
 
7949 
  def read(self, iprot):
7950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7952 
      return
7953 
    iprot.readStructBegin()
7954 
    while True:
7955 
      (fname, ftype, fid) = iprot.readFieldBegin()
7956 
      if ftype == TType.STOP:
7957 
        break
7958 
      if fid == 0:
7959 
        if ftype == TType.LIST:
7960 
          self.success = []
8590 kshitij.so 7961 
          (_etype49, _size46) = iprot.readListBegin()
7962 
          for _i50 in xrange(_size46):
7963 
            _elem51 = Item()
7964 
            _elem51.read(iprot)
7965 
            self.success.append(_elem51)
5944 mandeep.dh 7966 
          iprot.readListEnd()
7967 
        else:
7968 
          iprot.skip(ftype)
7969 
      elif fid == 1:
7970 
        if ftype == TType.STRUCT:
7971 
          self.cex = CatalogServiceException()
7972 
          self.cex.read(iprot)
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      else:
7976 
        iprot.skip(ftype)
7977 
      iprot.readFieldEnd()
7978 
    iprot.readStructEnd()
7979 
 
7980 
  def write(self, oprot):
7981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7983 
      return
7984 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7985 
    if self.success is not None:
7986 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7987 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7988 
      for iter52 in self.success:
7989 
        iter52.write(oprot)
5944 mandeep.dh 7990 
      oprot.writeListEnd()
7991 
      oprot.writeFieldEnd()
7992 
    if self.cex is not None:
7993 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7994 
      self.cex.write(oprot)
7995 
      oprot.writeFieldEnd()
7996 
    oprot.writeFieldStop()
7997 
    oprot.writeStructEnd()
7998 
 
7999 
  def validate(self):
8000 
    return
8001 
 
8002 
 
8003 
  def __repr__(self):
8004 
    L = ['%s=%r' % (key, value)
8005 
      for key, value in self.__dict__.iteritems()]
8006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8007 
 
8008 
  def __eq__(self, other):
8009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8010 
 
8011 
  def __ne__(self, other):
8012 
    return not (self == other)
8013 
 
8014 
class getValidItemsByCatalogId_args:
8015 
  """
8016 
  Attributes:
8017 
   - catalog_item_id
8018 
  """
8019 
 
8020 
  thrift_spec = (
8021 
    None, # 0
8022 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8023 
  )
8024 
 
8025 
  def __init__(self, catalog_item_id=None,):
8026 
    self.catalog_item_id = catalog_item_id
8027 
 
8028 
  def read(self, iprot):
8029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8031 
      return
8032 
    iprot.readStructBegin()
8033 
    while True:
8034 
      (fname, ftype, fid) = iprot.readFieldBegin()
8035 
      if ftype == TType.STOP:
8036 
        break
8037 
      if fid == 1:
8038 
        if ftype == TType.I64:
8039 
          self.catalog_item_id = iprot.readI64();
8040 
        else:
8041 
          iprot.skip(ftype)
8042 
      else:
8043 
        iprot.skip(ftype)
8044 
      iprot.readFieldEnd()
8045 
    iprot.readStructEnd()
8046 
 
8047 
  def write(self, oprot):
8048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8050 
      return
8051 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8052 
    if self.catalog_item_id is not None:
8053 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8054 
      oprot.writeI64(self.catalog_item_id)
8055 
      oprot.writeFieldEnd()
8056 
    oprot.writeFieldStop()
8057 
    oprot.writeStructEnd()
8058 
 
8059 
  def validate(self):
8060 
    return
8061 
 
8062 
 
8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
8074 
class getValidItemsByCatalogId_result:
8075 
  """
8076 
  Attributes:
8077 
   - success
8078 
   - cex
8079 
  """
8080 
 
8081 
  thrift_spec = (
8082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8083 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8084 
  )
8085 
 
8086 
  def __init__(self, success=None, cex=None,):
8087 
    self.success = success
8088 
    self.cex = cex
8089 
 
8090 
  def read(self, iprot):
8091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8093 
      return
8094 
    iprot.readStructBegin()
8095 
    while True:
8096 
      (fname, ftype, fid) = iprot.readFieldBegin()
8097 
      if ftype == TType.STOP:
8098 
        break
8099 
      if fid == 0:
8100 
        if ftype == TType.LIST:
8101 
          self.success = []
8590 kshitij.so 8102 
          (_etype56, _size53) = iprot.readListBegin()
8103 
          for _i57 in xrange(_size53):
8104 
            _elem58 = Item()
8105 
            _elem58.read(iprot)
8106 
            self.success.append(_elem58)
5944 mandeep.dh 8107 
          iprot.readListEnd()
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 1:
8111 
        if ftype == TType.STRUCT:
8112 
          self.cex = CatalogServiceException()
8113 
          self.cex.read(iprot)
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      else:
8117 
        iprot.skip(ftype)
8118 
      iprot.readFieldEnd()
8119 
    iprot.readStructEnd()
8120 
 
8121 
  def write(self, oprot):
8122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8124 
      return
8125 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8126 
    if self.success is not None:
8127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8129 
      for iter59 in self.success:
8130 
        iter59.write(oprot)
5944 mandeep.dh 8131 
      oprot.writeListEnd()
8132 
      oprot.writeFieldEnd()
8133 
    if self.cex is not None:
8134 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8135 
      self.cex.write(oprot)
8136 
      oprot.writeFieldEnd()
8137 
    oprot.writeFieldStop()
8138 
    oprot.writeStructEnd()
8139 
 
8140 
  def validate(self):
8141 
    return
8142 
 
8143 
 
8144 
  def __repr__(self):
8145 
    L = ['%s=%r' % (key, value)
8146 
      for key, value in self.__dict__.iteritems()]
8147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8148 
 
8149 
  def __eq__(self, other):
8150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8151 
 
8152 
  def __ne__(self, other):
8153 
    return not (self == other)
8154 
 
8155 
class getAllItems_args:
8156 
  """
8157 
  Attributes:
8158 
   - isActive
8159 
  """
8160 
 
8161 
  thrift_spec = (
8162 
    None, # 0
8163 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8164 
  )
8165 
 
8166 
  def __init__(self, isActive=None,):
8167 
    self.isActive = isActive
8168 
 
8169 
  def read(self, iprot):
8170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8172 
      return
8173 
    iprot.readStructBegin()
8174 
    while True:
8175 
      (fname, ftype, fid) = iprot.readFieldBegin()
8176 
      if ftype == TType.STOP:
8177 
        break
8178 
      if fid == 1:
8179 
        if ftype == TType.BOOL:
8180 
          self.isActive = iprot.readBool();
8181 
        else:
8182 
          iprot.skip(ftype)
8183 
      else:
8184 
        iprot.skip(ftype)
8185 
      iprot.readFieldEnd()
8186 
    iprot.readStructEnd()
8187 
 
8188 
  def write(self, oprot):
8189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8191 
      return
8192 
    oprot.writeStructBegin('getAllItems_args')
8193 
    if self.isActive is not None:
8194 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8195 
      oprot.writeBool(self.isActive)
8196 
      oprot.writeFieldEnd()
8197 
    oprot.writeFieldStop()
8198 
    oprot.writeStructEnd()
8199 
 
8200 
  def validate(self):
8201 
    return
8202 
 
8203 
 
8204 
  def __repr__(self):
8205 
    L = ['%s=%r' % (key, value)
8206 
      for key, value in self.__dict__.iteritems()]
8207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8208 
 
8209 
  def __eq__(self, other):
8210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8211 
 
8212 
  def __ne__(self, other):
8213 
    return not (self == other)
8214 
 
8215 
class getAllItems_result:
8216 
  """
8217 
  Attributes:
8218 
   - success
8219 
   - cex
8220 
  """
8221 
 
8222 
  thrift_spec = (
8223 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8224 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8225 
  )
8226 
 
8227 
  def __init__(self, success=None, cex=None,):
8228 
    self.success = success
8229 
    self.cex = cex
8230 
 
8231 
  def read(self, iprot):
8232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8234 
      return
8235 
    iprot.readStructBegin()
8236 
    while True:
8237 
      (fname, ftype, fid) = iprot.readFieldBegin()
8238 
      if ftype == TType.STOP:
8239 
        break
8240 
      if fid == 0:
8241 
        if ftype == TType.LIST:
8242 
          self.success = []
8590 kshitij.so 8243 
          (_etype63, _size60) = iprot.readListBegin()
8244 
          for _i64 in xrange(_size60):
8245 
            _elem65 = Item()
8246 
            _elem65.read(iprot)
8247 
            self.success.append(_elem65)
5944 mandeep.dh 8248 
          iprot.readListEnd()
8249 
        else:
8250 
          iprot.skip(ftype)
8251 
      elif fid == 1:
8252 
        if ftype == TType.STRUCT:
8253 
          self.cex = CatalogServiceException()
8254 
          self.cex.read(iprot)
8255 
        else:
8256 
          iprot.skip(ftype)
8257 
      else:
8258 
        iprot.skip(ftype)
8259 
      iprot.readFieldEnd()
8260 
    iprot.readStructEnd()
8261 
 
8262 
  def write(self, oprot):
8263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8265 
      return
8266 
    oprot.writeStructBegin('getAllItems_result')
8267 
    if self.success is not None:
8268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8269 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8270 
      for iter66 in self.success:
8271 
        iter66.write(oprot)
5944 mandeep.dh 8272 
      oprot.writeListEnd()
8273 
      oprot.writeFieldEnd()
8274 
    if self.cex is not None:
8275 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8276 
      self.cex.write(oprot)
8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
8296 
class getAllItemsByStatus_args:
8297 
  """
8298 
  Attributes:
8299 
   - itemStatus
8300 
  """
8301 
 
8302 
  thrift_spec = (
8303 
    None, # 0
8304 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8305 
  )
8306 
 
8307 
  def __init__(self, itemStatus=None,):
8308 
    self.itemStatus = itemStatus
8309 
 
8310 
  def read(self, iprot):
8311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8313 
      return
8314 
    iprot.readStructBegin()
8315 
    while True:
8316 
      (fname, ftype, fid) = iprot.readFieldBegin()
8317 
      if ftype == TType.STOP:
8318 
        break
8319 
      if fid == 1:
8320 
        if ftype == TType.I32:
8321 
          self.itemStatus = iprot.readI32();
8322 
        else:
8323 
          iprot.skip(ftype)
8324 
      else:
8325 
        iprot.skip(ftype)
8326 
      iprot.readFieldEnd()
8327 
    iprot.readStructEnd()
8328 
 
8329 
  def write(self, oprot):
8330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8332 
      return
8333 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8334 
    if self.itemStatus is not None:
8335 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8336 
      oprot.writeI32(self.itemStatus)
8337 
      oprot.writeFieldEnd()
8338 
    oprot.writeFieldStop()
8339 
    oprot.writeStructEnd()
8340 
 
8341 
  def validate(self):
8342 
    return
8343 
 
8344 
 
8345 
  def __repr__(self):
8346 
    L = ['%s=%r' % (key, value)
8347 
      for key, value in self.__dict__.iteritems()]
8348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8349 
 
8350 
  def __eq__(self, other):
8351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8352 
 
8353 
  def __ne__(self, other):
8354 
    return not (self == other)
8355 
 
8356 
class getAllItemsByStatus_result:
8357 
  """
8358 
  Attributes:
8359 
   - success
8360 
   - cex
8361 
  """
8362 
 
8363 
  thrift_spec = (
8364 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8365 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8366 
  )
8367 
 
8368 
  def __init__(self, success=None, cex=None,):
8369 
    self.success = success
8370 
    self.cex = cex
8371 
 
8372 
  def read(self, iprot):
8373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8375 
      return
8376 
    iprot.readStructBegin()
8377 
    while True:
8378 
      (fname, ftype, fid) = iprot.readFieldBegin()
8379 
      if ftype == TType.STOP:
8380 
        break
8381 
      if fid == 0:
8382 
        if ftype == TType.LIST:
8383 
          self.success = []
8590 kshitij.so 8384 
          (_etype70, _size67) = iprot.readListBegin()
8385 
          for _i71 in xrange(_size67):
8386 
            _elem72 = Item()
8387 
            _elem72.read(iprot)
8388 
            self.success.append(_elem72)
5944 mandeep.dh 8389 
          iprot.readListEnd()
8390 
        else:
8391 
          iprot.skip(ftype)
8392 
      elif fid == 1:
8393 
        if ftype == TType.STRUCT:
8394 
          self.cex = CatalogServiceException()
8395 
          self.cex.read(iprot)
8396 
        else:
8397 
          iprot.skip(ftype)
8398 
      else:
8399 
        iprot.skip(ftype)
8400 
      iprot.readFieldEnd()
8401 
    iprot.readStructEnd()
8402 
 
8403 
  def write(self, oprot):
8404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8406 
      return
8407 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8408 
    if self.success is not None:
8409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8411 
      for iter73 in self.success:
8412 
        iter73.write(oprot)
5944 mandeep.dh 8413 
      oprot.writeListEnd()
8414 
      oprot.writeFieldEnd()
8415 
    if self.cex is not None:
8416 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8417 
      self.cex.write(oprot)
8418 
      oprot.writeFieldEnd()
8419 
    oprot.writeFieldStop()
8420 
    oprot.writeStructEnd()
8421 
 
8422 
  def validate(self):
8423 
    return
8424 
 
8425 
 
8426 
  def __repr__(self):
8427 
    L = ['%s=%r' % (key, value)
8428 
      for key, value in self.__dict__.iteritems()]
8429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8430 
 
8431 
  def __eq__(self, other):
8432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8433 
 
8434 
  def __ne__(self, other):
8435 
    return not (self == other)
8436 
 
8437 
class markItemAsContentComplete_args:
8438 
  """
8439 
  Attributes:
8440 
   - entityId
8441 
   - category
8442 
   - brand
8443 
   - modelName
8444 
   - modelNumber
9253 rajveer 8445 
   - isAndroid
5944 mandeep.dh 8446 
  """
8447 
 
8448 
  thrift_spec = (
8449 
    None, # 0
8450 
    (1, TType.I64, 'entityId', None, None, ), # 1
8451 
    (2, TType.I64, 'category', None, None, ), # 2
8452 
    (3, TType.STRING, 'brand', None, None, ), # 3
8453 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8454 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 8455 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 8456 
  )
8457 
 
9253 rajveer 8458 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 8459 
    self.entityId = entityId
8460 
    self.category = category
8461 
    self.brand = brand
8462 
    self.modelName = modelName
8463 
    self.modelNumber = modelNumber
9253 rajveer 8464 
    self.isAndroid = isAndroid
5944 mandeep.dh 8465 
 
8466 
  def read(self, iprot):
8467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8469 
      return
8470 
    iprot.readStructBegin()
8471 
    while True:
8472 
      (fname, ftype, fid) = iprot.readFieldBegin()
8473 
      if ftype == TType.STOP:
8474 
        break
8475 
      if fid == 1:
8476 
        if ftype == TType.I64:
8477 
          self.entityId = iprot.readI64();
8478 
        else:
8479 
          iprot.skip(ftype)
8480 
      elif fid == 2:
8481 
        if ftype == TType.I64:
8482 
          self.category = iprot.readI64();
8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      elif fid == 3:
8486 
        if ftype == TType.STRING:
8487 
          self.brand = iprot.readString();
8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      elif fid == 4:
8491 
        if ftype == TType.STRING:
8492 
          self.modelName = iprot.readString();
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      elif fid == 5:
8496 
        if ftype == TType.STRING:
8497 
          self.modelNumber = iprot.readString();
8498 
        else:
8499 
          iprot.skip(ftype)
9253 rajveer 8500 
      elif fid == 6:
8501 
        if ftype == TType.BOOL:
8502 
          self.isAndroid = iprot.readBool();
8503 
        else:
8504 
          iprot.skip(ftype)
5944 mandeep.dh 8505 
      else:
8506 
        iprot.skip(ftype)
8507 
      iprot.readFieldEnd()
8508 
    iprot.readStructEnd()
8509 
 
8510 
  def write(self, oprot):
8511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8513 
      return
8514 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8515 
    if self.entityId is not None:
8516 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8517 
      oprot.writeI64(self.entityId)
8518 
      oprot.writeFieldEnd()
8519 
    if self.category is not None:
8520 
      oprot.writeFieldBegin('category', TType.I64, 2)
8521 
      oprot.writeI64(self.category)
8522 
      oprot.writeFieldEnd()
8523 
    if self.brand is not None:
8524 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8525 
      oprot.writeString(self.brand)
8526 
      oprot.writeFieldEnd()
8527 
    if self.modelName is not None:
8528 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8529 
      oprot.writeString(self.modelName)
8530 
      oprot.writeFieldEnd()
8531 
    if self.modelNumber is not None:
8532 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8533 
      oprot.writeString(self.modelNumber)
8534 
      oprot.writeFieldEnd()
9253 rajveer 8535 
    if self.isAndroid is not None:
8536 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
8537 
      oprot.writeBool(self.isAndroid)
8538 
      oprot.writeFieldEnd()
5944 mandeep.dh 8539 
    oprot.writeFieldStop()
8540 
    oprot.writeStructEnd()
8541 
 
8542 
  def validate(self):
8543 
    return
8544 
 
8545 
 
8546 
  def __repr__(self):
8547 
    L = ['%s=%r' % (key, value)
8548 
      for key, value in self.__dict__.iteritems()]
8549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8550 
 
8551 
  def __eq__(self, other):
8552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8553 
 
8554 
  def __ne__(self, other):
8555 
    return not (self == other)
8556 
 
8557 
class markItemAsContentComplete_result:
8558 
  """
8559 
  Attributes:
8560 
   - success
8561 
   - cex
8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    (0, TType.BOOL, 'success', None, None, ), # 0
8566 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8567 
  )
8568 
 
8569 
  def __init__(self, success=None, cex=None,):
8570 
    self.success = success
8571 
    self.cex = cex
8572 
 
8573 
  def read(self, iprot):
8574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8576 
      return
8577 
    iprot.readStructBegin()
8578 
    while True:
8579 
      (fname, ftype, fid) = iprot.readFieldBegin()
8580 
      if ftype == TType.STOP:
8581 
        break
8582 
      if fid == 0:
8583 
        if ftype == TType.BOOL:
8584 
          self.success = iprot.readBool();
8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      elif fid == 1:
8588 
        if ftype == TType.STRUCT:
8589 
          self.cex = CatalogServiceException()
8590 
          self.cex.read(iprot)
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      else:
8594 
        iprot.skip(ftype)
8595 
      iprot.readFieldEnd()
8596 
    iprot.readStructEnd()
8597 
 
8598 
  def write(self, oprot):
8599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8601 
      return
8602 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8603 
    if self.success is not None:
8604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8605 
      oprot.writeBool(self.success)
8606 
      oprot.writeFieldEnd()
8607 
    if self.cex is not None:
8608 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8609 
      self.cex.write(oprot)
8610 
      oprot.writeFieldEnd()
8611 
    oprot.writeFieldStop()
8612 
    oprot.writeStructEnd()
8613 
 
8614 
  def validate(self):
8615 
    return
8616 
 
8617 
 
8618 
  def __repr__(self):
8619 
    L = ['%s=%r' % (key, value)
8620 
      for key, value in self.__dict__.iteritems()]
8621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8622 
 
8623 
  def __eq__(self, other):
8624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8625 
 
8626 
  def __ne__(self, other):
8627 
    return not (self == other)
8628 
 
8629 
class getAllItemsInRange_args:
8630 
  """
8631 
  Attributes:
8632 
   - offset
8633 
   - limit
8634 
  """
8635 
 
8636 
  thrift_spec = (
8637 
    None, # 0
8638 
    (1, TType.I64, 'offset', None, None, ), # 1
8639 
    (2, TType.I64, 'limit', None, None, ), # 2
8640 
  )
8641 
 
8642 
  def __init__(self, offset=None, limit=None,):
8643 
    self.offset = offset
8644 
    self.limit = limit
8645 
 
8646 
  def read(self, iprot):
8647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8649 
      return
8650 
    iprot.readStructBegin()
8651 
    while True:
8652 
      (fname, ftype, fid) = iprot.readFieldBegin()
8653 
      if ftype == TType.STOP:
8654 
        break
8655 
      if fid == 1:
8656 
        if ftype == TType.I64:
8657 
          self.offset = iprot.readI64();
8658 
        else:
8659 
          iprot.skip(ftype)
8660 
      elif fid == 2:
8661 
        if ftype == TType.I64:
8662 
          self.limit = iprot.readI64();
8663 
        else:
8664 
          iprot.skip(ftype)
8665 
      else:
8666 
        iprot.skip(ftype)
8667 
      iprot.readFieldEnd()
8668 
    iprot.readStructEnd()
8669 
 
8670 
  def write(self, oprot):
8671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8673 
      return
8674 
    oprot.writeStructBegin('getAllItemsInRange_args')
8675 
    if self.offset is not None:
8676 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8677 
      oprot.writeI64(self.offset)
8678 
      oprot.writeFieldEnd()
8679 
    if self.limit is not None:
8680 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8681 
      oprot.writeI64(self.limit)
8682 
      oprot.writeFieldEnd()
8683 
    oprot.writeFieldStop()
8684 
    oprot.writeStructEnd()
8685 
 
8686 
  def validate(self):
8687 
    return
8688 
 
8689 
 
8690 
  def __repr__(self):
8691 
    L = ['%s=%r' % (key, value)
8692 
      for key, value in self.__dict__.iteritems()]
8693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8694 
 
8695 
  def __eq__(self, other):
8696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8697 
 
8698 
  def __ne__(self, other):
8699 
    return not (self == other)
8700 
 
8701 
class getAllItemsInRange_result:
8702 
  """
8703 
  Attributes:
8704 
   - success
8705 
   - cex
8706 
  """
8707 
 
8708 
  thrift_spec = (
8709 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8710 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8711 
  )
8712 
 
8713 
  def __init__(self, success=None, cex=None,):
8714 
    self.success = success
8715 
    self.cex = cex
8716 
 
8717 
  def read(self, iprot):
8718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8720 
      return
8721 
    iprot.readStructBegin()
8722 
    while True:
8723 
      (fname, ftype, fid) = iprot.readFieldBegin()
8724 
      if ftype == TType.STOP:
8725 
        break
8726 
      if fid == 0:
8727 
        if ftype == TType.LIST:
8728 
          self.success = []
8590 kshitij.so 8729 
          (_etype77, _size74) = iprot.readListBegin()
8730 
          for _i78 in xrange(_size74):
8731 
            _elem79 = Item()
8732 
            _elem79.read(iprot)
8733 
            self.success.append(_elem79)
5944 mandeep.dh 8734 
          iprot.readListEnd()
8735 
        else:
8736 
          iprot.skip(ftype)
8737 
      elif fid == 1:
8738 
        if ftype == TType.STRUCT:
8739 
          self.cex = CatalogServiceException()
8740 
          self.cex.read(iprot)
8741 
        else:
8742 
          iprot.skip(ftype)
8743 
      else:
8744 
        iprot.skip(ftype)
8745 
      iprot.readFieldEnd()
8746 
    iprot.readStructEnd()
8747 
 
8748 
  def write(self, oprot):
8749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8751 
      return
8752 
    oprot.writeStructBegin('getAllItemsInRange_result')
8753 
    if self.success is not None:
8754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8755 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8756 
      for iter80 in self.success:
8757 
        iter80.write(oprot)
5944 mandeep.dh 8758 
      oprot.writeListEnd()
8759 
      oprot.writeFieldEnd()
8760 
    if self.cex is not None:
8761 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8762 
      self.cex.write(oprot)
8763 
      oprot.writeFieldEnd()
8764 
    oprot.writeFieldStop()
8765 
    oprot.writeStructEnd()
8766 
 
8767 
  def validate(self):
8768 
    return
8769 
 
8770 
 
8771 
  def __repr__(self):
8772 
    L = ['%s=%r' % (key, value)
8773 
      for key, value in self.__dict__.iteritems()]
8774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8775 
 
8776 
  def __eq__(self, other):
8777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8778 
 
8779 
  def __ne__(self, other):
8780 
    return not (self == other)
8781 
 
8782 
class getAllItemsByStatusInRange_args:
8783 
  """
8784 
  Attributes:
8785 
   - itemStatus
8786 
   - offset
8787 
   - limit
8788 
  """
8789 
 
8790 
  thrift_spec = (
8791 
    None, # 0
8792 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8793 
    (2, TType.I64, 'offset', None, None, ), # 2
8794 
    (3, TType.I64, 'limit', None, None, ), # 3
8795 
  )
8796 
 
8797 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8798 
    self.itemStatus = itemStatus
8799 
    self.offset = offset
8800 
    self.limit = limit
8801 
 
8802 
  def read(self, iprot):
8803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8805 
      return
8806 
    iprot.readStructBegin()
8807 
    while True:
8808 
      (fname, ftype, fid) = iprot.readFieldBegin()
8809 
      if ftype == TType.STOP:
8810 
        break
8811 
      if fid == 1:
8812 
        if ftype == TType.I32:
8813 
          self.itemStatus = iprot.readI32();
8814 
        else:
8815 
          iprot.skip(ftype)
8816 
      elif fid == 2:
8817 
        if ftype == TType.I64:
8818 
          self.offset = iprot.readI64();
8819 
        else:
8820 
          iprot.skip(ftype)
8821 
      elif fid == 3:
8822 
        if ftype == TType.I64:
8823 
          self.limit = iprot.readI64();
8824 
        else:
8825 
          iprot.skip(ftype)
8826 
      else:
8827 
        iprot.skip(ftype)
8828 
      iprot.readFieldEnd()
8829 
    iprot.readStructEnd()
8830 
 
8831 
  def write(self, oprot):
8832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8834 
      return
8835 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8836 
    if self.itemStatus is not None:
8837 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8838 
      oprot.writeI32(self.itemStatus)
8839 
      oprot.writeFieldEnd()
8840 
    if self.offset is not None:
8841 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8842 
      oprot.writeI64(self.offset)
8843 
      oprot.writeFieldEnd()
8844 
    if self.limit is not None:
8845 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8846 
      oprot.writeI64(self.limit)
8847 
      oprot.writeFieldEnd()
8848 
    oprot.writeFieldStop()
8849 
    oprot.writeStructEnd()
8850 
 
8851 
  def validate(self):
8852 
    return
8853 
 
8854 
 
8855 
  def __repr__(self):
8856 
    L = ['%s=%r' % (key, value)
8857 
      for key, value in self.__dict__.iteritems()]
8858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8859 
 
8860 
  def __eq__(self, other):
8861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8862 
 
8863 
  def __ne__(self, other):
8864 
    return not (self == other)
8865 
 
8866 
class getAllItemsByStatusInRange_result:
8867 
  """
8868 
  Attributes:
8869 
   - success
8870 
   - cex
8871 
  """
8872 
 
8873 
  thrift_spec = (
8874 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8875 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8876 
  )
8877 
 
8878 
  def __init__(self, success=None, cex=None,):
8879 
    self.success = success
8880 
    self.cex = cex
8881 
 
8882 
  def read(self, iprot):
8883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8885 
      return
8886 
    iprot.readStructBegin()
8887 
    while True:
8888 
      (fname, ftype, fid) = iprot.readFieldBegin()
8889 
      if ftype == TType.STOP:
8890 
        break
8891 
      if fid == 0:
8892 
        if ftype == TType.LIST:
8893 
          self.success = []
8590 kshitij.so 8894 
          (_etype84, _size81) = iprot.readListBegin()
8895 
          for _i85 in xrange(_size81):
8896 
            _elem86 = Item()
8897 
            _elem86.read(iprot)
8898 
            self.success.append(_elem86)
5944 mandeep.dh 8899 
          iprot.readListEnd()
8900 
        else:
8901 
          iprot.skip(ftype)
8902 
      elif fid == 1:
8903 
        if ftype == TType.STRUCT:
8904 
          self.cex = CatalogServiceException()
8905 
          self.cex.read(iprot)
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
8917 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8918 
    if self.success is not None:
8919 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8920 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8921 
      for iter87 in self.success:
8922 
        iter87.write(oprot)
5944 mandeep.dh 8923 
      oprot.writeListEnd()
8924 
      oprot.writeFieldEnd()
8925 
    if self.cex is not None:
8926 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8927 
      self.cex.write(oprot)
8928 
      oprot.writeFieldEnd()
8929 
    oprot.writeFieldStop()
8930 
    oprot.writeStructEnd()
8931 
 
8932 
  def validate(self):
8933 
    return
8934 
 
8935 
 
8936 
  def __repr__(self):
8937 
    L = ['%s=%r' % (key, value)
8938 
      for key, value in self.__dict__.iteritems()]
8939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8940 
 
8941 
  def __eq__(self, other):
8942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8943 
 
8944 
  def __ne__(self, other):
8945 
    return not (self == other)
8946 
 
8947 
class getItemCountByStatus_args:
8948 
  """
8949 
  Attributes:
8950 
   - useStatus
8951 
   - itemStatus
8952 
  """
8953 
 
8954 
  thrift_spec = (
8955 
    None, # 0
8956 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8957 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8958 
  )
8959 
 
8960 
  def __init__(self, useStatus=None, itemStatus=None,):
8961 
    self.useStatus = useStatus
8962 
    self.itemStatus = itemStatus
8963 
 
8964 
  def read(self, iprot):
8965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8967 
      return
8968 
    iprot.readStructBegin()
8969 
    while True:
8970 
      (fname, ftype, fid) = iprot.readFieldBegin()
8971 
      if ftype == TType.STOP:
8972 
        break
8973 
      if fid == 1:
8974 
        if ftype == TType.BOOL:
8975 
          self.useStatus = iprot.readBool();
8976 
        else:
8977 
          iprot.skip(ftype)
8978 
      elif fid == 2:
8979 
        if ftype == TType.I32:
8980 
          self.itemStatus = iprot.readI32();
8981 
        else:
8982 
          iprot.skip(ftype)
8983 
      else:
8984 
        iprot.skip(ftype)
8985 
      iprot.readFieldEnd()
8986 
    iprot.readStructEnd()
8987 
 
8988 
  def write(self, oprot):
8989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8991 
      return
8992 
    oprot.writeStructBegin('getItemCountByStatus_args')
8993 
    if self.useStatus is not None:
8994 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8995 
      oprot.writeBool(self.useStatus)
8996 
      oprot.writeFieldEnd()
8997 
    if self.itemStatus is not None:
8998 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8999 
      oprot.writeI32(self.itemStatus)
9000 
      oprot.writeFieldEnd()
9001 
    oprot.writeFieldStop()
9002 
    oprot.writeStructEnd()
9003 
 
9004 
  def validate(self):
9005 
    return
9006 
 
9007 
 
9008 
  def __repr__(self):
9009 
    L = ['%s=%r' % (key, value)
9010 
      for key, value in self.__dict__.iteritems()]
9011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9012 
 
9013 
  def __eq__(self, other):
9014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9015 
 
9016 
  def __ne__(self, other):
9017 
    return not (self == other)
9018 
 
9019 
class getItemCountByStatus_result:
9020 
  """
9021 
  Attributes:
9022 
   - success
9023 
  """
9024 
 
9025 
  thrift_spec = (
9026 
    (0, TType.I32, 'success', None, None, ), # 0
9027 
  )
9028 
 
9029 
  def __init__(self, success=None,):
9030 
    self.success = success
9031 
 
9032 
  def read(self, iprot):
9033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9035 
      return
9036 
    iprot.readStructBegin()
9037 
    while True:
9038 
      (fname, ftype, fid) = iprot.readFieldBegin()
9039 
      if ftype == TType.STOP:
9040 
        break
9041 
      if fid == 0:
9042 
        if ftype == TType.I32:
9043 
          self.success = iprot.readI32();
9044 
        else:
9045 
          iprot.skip(ftype)
9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
9055 
    oprot.writeStructBegin('getItemCountByStatus_result')
9056 
    if self.success is not None:
9057 
      oprot.writeFieldBegin('success', TType.I32, 0)
9058 
      oprot.writeI32(self.success)
9059 
      oprot.writeFieldEnd()
9060 
    oprot.writeFieldStop()
9061 
    oprot.writeStructEnd()
9062 
 
9063 
  def validate(self):
9064 
    return
9065 
 
9066 
 
9067 
  def __repr__(self):
9068 
    L = ['%s=%r' % (key, value)
9069 
      for key, value in self.__dict__.iteritems()]
9070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9071 
 
9072 
  def __eq__(self, other):
9073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9074 
 
9075 
  def __ne__(self, other):
9076 
    return not (self == other)
9077 
 
9078 
class getBestSellers_args:
9079 
 
9080 
  thrift_spec = (
9081 
  )
9082 
 
9083 
  def read(self, iprot):
9084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9086 
      return
9087 
    iprot.readStructBegin()
9088 
    while True:
9089 
      (fname, ftype, fid) = iprot.readFieldBegin()
9090 
      if ftype == TType.STOP:
9091 
        break
9092 
      else:
9093 
        iprot.skip(ftype)
9094 
      iprot.readFieldEnd()
9095 
    iprot.readStructEnd()
9096 
 
9097 
  def write(self, oprot):
9098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9100 
      return
9101 
    oprot.writeStructBegin('getBestSellers_args')
9102 
    oprot.writeFieldStop()
9103 
    oprot.writeStructEnd()
9104 
 
9105 
  def validate(self):
9106 
    return
9107 
 
9108 
 
9109 
  def __repr__(self):
9110 
    L = ['%s=%r' % (key, value)
9111 
      for key, value in self.__dict__.iteritems()]
9112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9113 
 
9114 
  def __eq__(self, other):
9115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9116 
 
9117 
  def __ne__(self, other):
9118 
    return not (self == other)
9119 
 
9120 
class getBestSellers_result:
9121 
  """
9122 
  Attributes:
9123 
   - success
9124 
   - isex
9125 
  """
9126 
 
9127 
  thrift_spec = (
9128 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9129 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9130 
  )
9131 
 
9132 
  def __init__(self, success=None, isex=None,):
9133 
    self.success = success
9134 
    self.isex = isex
9135 
 
9136 
  def read(self, iprot):
9137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9139 
      return
9140 
    iprot.readStructBegin()
9141 
    while True:
9142 
      (fname, ftype, fid) = iprot.readFieldBegin()
9143 
      if ftype == TType.STOP:
9144 
        break
9145 
      if fid == 0:
9146 
        if ftype == TType.LIST:
9147 
          self.success = []
8590 kshitij.so 9148 
          (_etype91, _size88) = iprot.readListBegin()
9149 
          for _i92 in xrange(_size88):
9150 
            _elem93 = Item()
9151 
            _elem93.read(iprot)
9152 
            self.success.append(_elem93)
5944 mandeep.dh 9153 
          iprot.readListEnd()
9154 
        else:
9155 
          iprot.skip(ftype)
9156 
      elif fid == 1:
9157 
        if ftype == TType.STRUCT:
9158 
          self.isex = CatalogServiceException()
9159 
          self.isex.read(iprot)
9160 
        else:
9161 
          iprot.skip(ftype)
9162 
      else:
9163 
        iprot.skip(ftype)
9164 
      iprot.readFieldEnd()
9165 
    iprot.readStructEnd()
9166 
 
9167 
  def write(self, oprot):
9168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9170 
      return
9171 
    oprot.writeStructBegin('getBestSellers_result')
9172 
    if self.success is not None:
9173 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9174 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9175 
      for iter94 in self.success:
9176 
        iter94.write(oprot)
5944 mandeep.dh 9177 
      oprot.writeListEnd()
9178 
      oprot.writeFieldEnd()
9179 
    if self.isex is not None:
9180 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9181 
      self.isex.write(oprot)
9182 
      oprot.writeFieldEnd()
9183 
    oprot.writeFieldStop()
9184 
    oprot.writeStructEnd()
9185 
 
9186 
  def validate(self):
9187 
    return
9188 
 
9189 
 
9190 
  def __repr__(self):
9191 
    L = ['%s=%r' % (key, value)
9192 
      for key, value in self.__dict__.iteritems()]
9193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9194 
 
9195 
  def __eq__(self, other):
9196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9197 
 
9198 
  def __ne__(self, other):
9199 
    return not (self == other)
9200 
 
9201 
class getBestSellersCatalogIds_args:
9202 
  """
9203 
  Attributes:
9204 
   - beginIndex
9205 
   - totalItems
9206 
   - brand
9207 
   - category
9208 
  """
9209 
 
9210 
  thrift_spec = (
9211 
    None, # 0
9212 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9213 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9214 
    (3, TType.STRING, 'brand', None, None, ), # 3
9215 
    (4, TType.I64, 'category', None, None, ), # 4
9216 
  )
9217 
 
9218 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9219 
    self.beginIndex = beginIndex
9220 
    self.totalItems = totalItems
9221 
    self.brand = brand
9222 
    self.category = category
9223 
 
9224 
  def read(self, iprot):
9225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9227 
      return
9228 
    iprot.readStructBegin()
9229 
    while True:
9230 
      (fname, ftype, fid) = iprot.readFieldBegin()
9231 
      if ftype == TType.STOP:
9232 
        break
9233 
      if fid == 1:
9234 
        if ftype == TType.I64:
9235 
          self.beginIndex = iprot.readI64();
9236 
        else:
9237 
          iprot.skip(ftype)
9238 
      elif fid == 2:
9239 
        if ftype == TType.I64:
9240 
          self.totalItems = iprot.readI64();
9241 
        else:
9242 
          iprot.skip(ftype)
9243 
      elif fid == 3:
9244 
        if ftype == TType.STRING:
9245 
          self.brand = iprot.readString();
9246 
        else:
9247 
          iprot.skip(ftype)
9248 
      elif fid == 4:
9249 
        if ftype == TType.I64:
9250 
          self.category = iprot.readI64();
9251 
        else:
9252 
          iprot.skip(ftype)
9253 
      else:
9254 
        iprot.skip(ftype)
9255 
      iprot.readFieldEnd()
9256 
    iprot.readStructEnd()
9257 
 
9258 
  def write(self, oprot):
9259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9261 
      return
9262 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9263 
    if self.beginIndex is not None:
9264 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9265 
      oprot.writeI64(self.beginIndex)
9266 
      oprot.writeFieldEnd()
9267 
    if self.totalItems is not None:
9268 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9269 
      oprot.writeI64(self.totalItems)
9270 
      oprot.writeFieldEnd()
9271 
    if self.brand is not None:
9272 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9273 
      oprot.writeString(self.brand)
9274 
      oprot.writeFieldEnd()
9275 
    if self.category is not None:
9276 
      oprot.writeFieldBegin('category', TType.I64, 4)
9277 
      oprot.writeI64(self.category)
9278 
      oprot.writeFieldEnd()
9279 
    oprot.writeFieldStop()
9280 
    oprot.writeStructEnd()
9281 
 
9282 
  def validate(self):
9283 
    return
9284 
 
9285 
 
9286 
  def __repr__(self):
9287 
    L = ['%s=%r' % (key, value)
9288 
      for key, value in self.__dict__.iteritems()]
9289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9290 
 
9291 
  def __eq__(self, other):
9292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9293 
 
9294 
  def __ne__(self, other):
9295 
    return not (self == other)
9296 
 
9297 
class getBestSellersCatalogIds_result:
9298 
  """
9299 
  Attributes:
9300 
   - success
9301 
   - cex
9302 
  """
9303 
 
9304 
  thrift_spec = (
9305 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9306 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9307 
  )
9308 
 
9309 
  def __init__(self, success=None, cex=None,):
9310 
    self.success = success
9311 
    self.cex = cex
9312 
 
9313 
  def read(self, iprot):
9314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9316 
      return
9317 
    iprot.readStructBegin()
9318 
    while True:
9319 
      (fname, ftype, fid) = iprot.readFieldBegin()
9320 
      if ftype == TType.STOP:
9321 
        break
9322 
      if fid == 0:
9323 
        if ftype == TType.LIST:
9324 
          self.success = []
8590 kshitij.so 9325 
          (_etype98, _size95) = iprot.readListBegin()
9326 
          for _i99 in xrange(_size95):
9327 
            _elem100 = iprot.readI64();
9328 
            self.success.append(_elem100)
5944 mandeep.dh 9329 
          iprot.readListEnd()
9330 
        else:
9331 
          iprot.skip(ftype)
9332 
      elif fid == 1:
9333 
        if ftype == TType.STRUCT:
9334 
          self.cex = CatalogServiceException()
9335 
          self.cex.read(iprot)
9336 
        else:
9337 
          iprot.skip(ftype)
9338 
      else:
9339 
        iprot.skip(ftype)
9340 
      iprot.readFieldEnd()
9341 
    iprot.readStructEnd()
9342 
 
9343 
  def write(self, oprot):
9344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9346 
      return
9347 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9348 
    if self.success is not None:
9349 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9350 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9351 
      for iter101 in self.success:
9352 
        oprot.writeI64(iter101)
5944 mandeep.dh 9353 
      oprot.writeListEnd()
9354 
      oprot.writeFieldEnd()
9355 
    if self.cex is not None:
9356 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9357 
      self.cex.write(oprot)
9358 
      oprot.writeFieldEnd()
9359 
    oprot.writeFieldStop()
9360 
    oprot.writeStructEnd()
9361 
 
9362 
  def validate(self):
9363 
    return
9364 
 
9365 
 
9366 
  def __repr__(self):
9367 
    L = ['%s=%r' % (key, value)
9368 
      for key, value in self.__dict__.iteritems()]
9369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9370 
 
9371 
  def __eq__(self, other):
9372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9373 
 
9374 
  def __ne__(self, other):
9375 
    return not (self == other)
9376 
 
9377 
class getBestSellersCount_args:
9378 
 
9379 
  thrift_spec = (
9380 
  )
9381 
 
9382 
  def read(self, iprot):
9383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9385 
      return
9386 
    iprot.readStructBegin()
9387 
    while True:
9388 
      (fname, ftype, fid) = iprot.readFieldBegin()
9389 
      if ftype == TType.STOP:
9390 
        break
9391 
      else:
9392 
        iprot.skip(ftype)
9393 
      iprot.readFieldEnd()
9394 
    iprot.readStructEnd()
9395 
 
9396 
  def write(self, oprot):
9397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9399 
      return
9400 
    oprot.writeStructBegin('getBestSellersCount_args')
9401 
    oprot.writeFieldStop()
9402 
    oprot.writeStructEnd()
9403 
 
9404 
  def validate(self):
9405 
    return
9406 
 
9407 
 
9408 
  def __repr__(self):
9409 
    L = ['%s=%r' % (key, value)
9410 
      for key, value in self.__dict__.iteritems()]
9411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9412 
 
9413 
  def __eq__(self, other):
9414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9415 
 
9416 
  def __ne__(self, other):
9417 
    return not (self == other)
9418 
 
9419 
class getBestSellersCount_result:
9420 
  """
9421 
  Attributes:
9422 
   - success
9423 
   - cex
9424 
  """
9425 
 
9426 
  thrift_spec = (
9427 
    (0, TType.I64, 'success', None, None, ), # 0
9428 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9429 
  )
9430 
 
9431 
  def __init__(self, success=None, cex=None,):
9432 
    self.success = success
9433 
    self.cex = cex
9434 
 
9435 
  def read(self, iprot):
9436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9438 
      return
9439 
    iprot.readStructBegin()
9440 
    while True:
9441 
      (fname, ftype, fid) = iprot.readFieldBegin()
9442 
      if ftype == TType.STOP:
9443 
        break
9444 
      if fid == 0:
9445 
        if ftype == TType.I64:
9446 
          self.success = iprot.readI64();
9447 
        else:
9448 
          iprot.skip(ftype)
9449 
      elif fid == 1:
9450 
        if ftype == TType.STRUCT:
9451 
          self.cex = CatalogServiceException()
9452 
          self.cex.read(iprot)
9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      else:
9456 
        iprot.skip(ftype)
9457 
      iprot.readFieldEnd()
9458 
    iprot.readStructEnd()
9459 
 
9460 
  def write(self, oprot):
9461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9463 
      return
9464 
    oprot.writeStructBegin('getBestSellersCount_result')
9465 
    if self.success is not None:
9466 
      oprot.writeFieldBegin('success', TType.I64, 0)
9467 
      oprot.writeI64(self.success)
9468 
      oprot.writeFieldEnd()
9469 
    if self.cex is not None:
9470 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9471 
      self.cex.write(oprot)
9472 
      oprot.writeFieldEnd()
9473 
    oprot.writeFieldStop()
9474 
    oprot.writeStructEnd()
9475 
 
9476 
  def validate(self):
9477 
    return
9478 
 
9479 
 
9480 
  def __repr__(self):
9481 
    L = ['%s=%r' % (key, value)
9482 
      for key, value in self.__dict__.iteritems()]
9483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9484 
 
9485 
  def __eq__(self, other):
9486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9487 
 
9488 
  def __ne__(self, other):
9489 
    return not (self == other)
9490 
 
9491 
class getBestDeals_args:
9492 
 
9493 
  thrift_spec = (
9494 
  )
9495 
 
9496 
  def read(self, iprot):
9497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9499 
      return
9500 
    iprot.readStructBegin()
9501 
    while True:
9502 
      (fname, ftype, fid) = iprot.readFieldBegin()
9503 
      if ftype == TType.STOP:
9504 
        break
9505 
      else:
9506 
        iprot.skip(ftype)
9507 
      iprot.readFieldEnd()
9508 
    iprot.readStructEnd()
9509 
 
9510 
  def write(self, oprot):
9511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9513 
      return
9514 
    oprot.writeStructBegin('getBestDeals_args')
9515 
    oprot.writeFieldStop()
9516 
    oprot.writeStructEnd()
9517 
 
9518 
  def validate(self):
9519 
    return
9520 
 
9521 
 
9522 
  def __repr__(self):
9523 
    L = ['%s=%r' % (key, value)
9524 
      for key, value in self.__dict__.iteritems()]
9525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9526 
 
9527 
  def __eq__(self, other):
9528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9529 
 
9530 
  def __ne__(self, other):
9531 
    return not (self == other)
9532 
 
9533 
class getBestDeals_result:
9534 
  """
9535 
  Attributes:
9536 
   - success
9537 
   - isex
9538 
  """
9539 
 
9540 
  thrift_spec = (
9541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9542 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9543 
  )
9544 
 
9545 
  def __init__(self, success=None, isex=None,):
9546 
    self.success = success
9547 
    self.isex = isex
9548 
 
9549 
  def read(self, iprot):
9550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9552 
      return
9553 
    iprot.readStructBegin()
9554 
    while True:
9555 
      (fname, ftype, fid) = iprot.readFieldBegin()
9556 
      if ftype == TType.STOP:
9557 
        break
9558 
      if fid == 0:
9559 
        if ftype == TType.LIST:
9560 
          self.success = []
8590 kshitij.so 9561 
          (_etype105, _size102) = iprot.readListBegin()
9562 
          for _i106 in xrange(_size102):
9563 
            _elem107 = Item()
9564 
            _elem107.read(iprot)
9565 
            self.success.append(_elem107)
5944 mandeep.dh 9566 
          iprot.readListEnd()
9567 
        else:
9568 
          iprot.skip(ftype)
9569 
      elif fid == 1:
9570 
        if ftype == TType.STRUCT:
9571 
          self.isex = CatalogServiceException()
9572 
          self.isex.read(iprot)
9573 
        else:
9574 
          iprot.skip(ftype)
9575 
      else:
9576 
        iprot.skip(ftype)
9577 
      iprot.readFieldEnd()
9578 
    iprot.readStructEnd()
9579 
 
9580 
  def write(self, oprot):
9581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9583 
      return
9584 
    oprot.writeStructBegin('getBestDeals_result')
9585 
    if self.success is not None:
9586 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9587 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9588 
      for iter108 in self.success:
9589 
        iter108.write(oprot)
5944 mandeep.dh 9590 
      oprot.writeListEnd()
9591 
      oprot.writeFieldEnd()
9592 
    if self.isex is not None:
9593 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9594 
      self.isex.write(oprot)
9595 
      oprot.writeFieldEnd()
9596 
    oprot.writeFieldStop()
9597 
    oprot.writeStructEnd()
9598 
 
9599 
  def validate(self):
9600 
    return
9601 
 
9602 
 
9603 
  def __repr__(self):
9604 
    L = ['%s=%r' % (key, value)
9605 
      for key, value in self.__dict__.iteritems()]
9606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9607 
 
9608 
  def __eq__(self, other):
9609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9610 
 
9611 
  def __ne__(self, other):
9612 
    return not (self == other)
9613 
 
9614 
class getBestDealsCatalogIds_args:
9615 
  """
9616 
  Attributes:
9617 
   - beginIndex
9618 
   - totalItems
9619 
   - brand
9620 
   - category
9621 
  """
9622 
 
9623 
  thrift_spec = (
9624 
    None, # 0
9625 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9626 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9627 
    (3, TType.STRING, 'brand', None, None, ), # 3
9628 
    (4, TType.I64, 'category', None, None, ), # 4
9629 
  )
9630 
 
9631 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9632 
    self.beginIndex = beginIndex
9633 
    self.totalItems = totalItems
9634 
    self.brand = brand
9635 
    self.category = category
9636 
 
9637 
  def read(self, iprot):
9638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9640 
      return
9641 
    iprot.readStructBegin()
9642 
    while True:
9643 
      (fname, ftype, fid) = iprot.readFieldBegin()
9644 
      if ftype == TType.STOP:
9645 
        break
9646 
      if fid == 1:
9647 
        if ftype == TType.I64:
9648 
          self.beginIndex = iprot.readI64();
9649 
        else:
9650 
          iprot.skip(ftype)
9651 
      elif fid == 2:
9652 
        if ftype == TType.I64:
9653 
          self.totalItems = iprot.readI64();
9654 
        else:
9655 
          iprot.skip(ftype)
9656 
      elif fid == 3:
9657 
        if ftype == TType.STRING:
9658 
          self.brand = iprot.readString();
9659 
        else:
9660 
          iprot.skip(ftype)
9661 
      elif fid == 4:
9662 
        if ftype == TType.I64:
9663 
          self.category = iprot.readI64();
9664 
        else:
9665 
          iprot.skip(ftype)
9666 
      else:
9667 
        iprot.skip(ftype)
9668 
      iprot.readFieldEnd()
9669 
    iprot.readStructEnd()
9670 
 
9671 
  def write(self, oprot):
9672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9674 
      return
9675 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9676 
    if self.beginIndex is not None:
9677 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9678 
      oprot.writeI64(self.beginIndex)
9679 
      oprot.writeFieldEnd()
9680 
    if self.totalItems is not None:
9681 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9682 
      oprot.writeI64(self.totalItems)
9683 
      oprot.writeFieldEnd()
9684 
    if self.brand is not None:
9685 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9686 
      oprot.writeString(self.brand)
9687 
      oprot.writeFieldEnd()
9688 
    if self.category is not None:
9689 
      oprot.writeFieldBegin('category', TType.I64, 4)
9690 
      oprot.writeI64(self.category)
9691 
      oprot.writeFieldEnd()
9692 
    oprot.writeFieldStop()
9693 
    oprot.writeStructEnd()
9694 
 
9695 
  def validate(self):
9696 
    return
9697 
 
9698 
 
9699 
  def __repr__(self):
9700 
    L = ['%s=%r' % (key, value)
9701 
      for key, value in self.__dict__.iteritems()]
9702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9703 
 
9704 
  def __eq__(self, other):
9705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9706 
 
9707 
  def __ne__(self, other):
9708 
    return not (self == other)
9709 
 
9710 
class getBestDealsCatalogIds_result:
9711 
  """
9712 
  Attributes:
9713 
   - success
9714 
   - cex
9715 
  """
9716 
 
9717 
  thrift_spec = (
9718 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9719 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9720 
  )
9721 
 
9722 
  def __init__(self, success=None, cex=None,):
9723 
    self.success = success
9724 
    self.cex = cex
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 0:
9736 
        if ftype == TType.LIST:
9737 
          self.success = []
8590 kshitij.so 9738 
          (_etype112, _size109) = iprot.readListBegin()
9739 
          for _i113 in xrange(_size109):
9740 
            _elem114 = iprot.readI64();
9741 
            self.success.append(_elem114)
5944 mandeep.dh 9742 
          iprot.readListEnd()
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      elif fid == 1:
9746 
        if ftype == TType.STRUCT:
9747 
          self.cex = CatalogServiceException()
9748 
          self.cex.read(iprot)
9749 
        else:
9750 
          iprot.skip(ftype)
9751 
      else:
9752 
        iprot.skip(ftype)
9753 
      iprot.readFieldEnd()
9754 
    iprot.readStructEnd()
9755 
 
9756 
  def write(self, oprot):
9757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9759 
      return
9760 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9761 
    if self.success is not None:
9762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9763 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9764 
      for iter115 in self.success:
9765 
        oprot.writeI64(iter115)
5944 mandeep.dh 9766 
      oprot.writeListEnd()
9767 
      oprot.writeFieldEnd()
9768 
    if self.cex is not None:
9769 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9770 
      self.cex.write(oprot)
9771 
      oprot.writeFieldEnd()
9772 
    oprot.writeFieldStop()
9773 
    oprot.writeStructEnd()
9774 
 
9775 
  def validate(self):
9776 
    return
9777 
 
9778 
 
9779 
  def __repr__(self):
9780 
    L = ['%s=%r' % (key, value)
9781 
      for key, value in self.__dict__.iteritems()]
9782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9783 
 
9784 
  def __eq__(self, other):
9785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9786 
 
9787 
  def __ne__(self, other):
9788 
    return not (self == other)
9789 
 
9790 
class getBestDealsCount_args:
9791 
 
9792 
  thrift_spec = (
9793 
  )
9794 
 
9795 
  def read(self, iprot):
9796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9798 
      return
9799 
    iprot.readStructBegin()
9800 
    while True:
9801 
      (fname, ftype, fid) = iprot.readFieldBegin()
9802 
      if ftype == TType.STOP:
9803 
        break
9804 
      else:
9805 
        iprot.skip(ftype)
9806 
      iprot.readFieldEnd()
9807 
    iprot.readStructEnd()
9808 
 
9809 
  def write(self, oprot):
9810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9812 
      return
9813 
    oprot.writeStructBegin('getBestDealsCount_args')
9814 
    oprot.writeFieldStop()
9815 
    oprot.writeStructEnd()
9816 
 
9817 
  def validate(self):
9818 
    return
9819 
 
9820 
 
9821 
  def __repr__(self):
9822 
    L = ['%s=%r' % (key, value)
9823 
      for key, value in self.__dict__.iteritems()]
9824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9825 
 
9826 
  def __eq__(self, other):
9827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9828 
 
9829 
  def __ne__(self, other):
9830 
    return not (self == other)
9831 
 
9832 
class getBestDealsCount_result:
9833 
  """
9834 
  Attributes:
9835 
   - success
9836 
   - cex
9837 
  """
9838 
 
9839 
  thrift_spec = (
9840 
    (0, TType.I64, 'success', None, None, ), # 0
9841 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9842 
  )
9843 
 
9844 
  def __init__(self, success=None, cex=None,):
9845 
    self.success = success
9846 
    self.cex = cex
9847 
 
9848 
  def read(self, iprot):
9849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9851 
      return
9852 
    iprot.readStructBegin()
9853 
    while True:
9854 
      (fname, ftype, fid) = iprot.readFieldBegin()
9855 
      if ftype == TType.STOP:
9856 
        break
9857 
      if fid == 0:
9858 
        if ftype == TType.I64:
9859 
          self.success = iprot.readI64();
9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      elif fid == 1:
9863 
        if ftype == TType.STRUCT:
9864 
          self.cex = CatalogServiceException()
9865 
          self.cex.read(iprot)
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      else:
9869 
        iprot.skip(ftype)
9870 
      iprot.readFieldEnd()
9871 
    iprot.readStructEnd()
9872 
 
9873 
  def write(self, oprot):
9874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9876 
      return
9877 
    oprot.writeStructBegin('getBestDealsCount_result')
9878 
    if self.success is not None:
9879 
      oprot.writeFieldBegin('success', TType.I64, 0)
9880 
      oprot.writeI64(self.success)
9881 
      oprot.writeFieldEnd()
9882 
    if self.cex is not None:
9883 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9884 
      self.cex.write(oprot)
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
9904 
class getComingSoon_args:
9905 
 
9906 
  thrift_spec = (
9907 
  )
9908 
 
9909 
  def read(self, iprot):
9910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9912 
      return
9913 
    iprot.readStructBegin()
9914 
    while True:
9915 
      (fname, ftype, fid) = iprot.readFieldBegin()
9916 
      if ftype == TType.STOP:
9917 
        break
9918 
      else:
9919 
        iprot.skip(ftype)
9920 
      iprot.readFieldEnd()
9921 
    iprot.readStructEnd()
9922 
 
9923 
  def write(self, oprot):
9924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9926 
      return
9927 
    oprot.writeStructBegin('getComingSoon_args')
9928 
    oprot.writeFieldStop()
9929 
    oprot.writeStructEnd()
9930 
 
9931 
  def validate(self):
9932 
    return
9933 
 
9934 
 
9935 
  def __repr__(self):
9936 
    L = ['%s=%r' % (key, value)
9937 
      for key, value in self.__dict__.iteritems()]
9938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9939 
 
9940 
  def __eq__(self, other):
9941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9942 
 
9943 
  def __ne__(self, other):
9944 
    return not (self == other)
9945 
 
9946 
class getComingSoon_result:
9947 
  """
9948 
  Attributes:
9949 
   - success
9950 
   - isex
9951 
  """
9952 
 
9953 
  thrift_spec = (
9954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9955 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9956 
  )
9957 
 
9958 
  def __init__(self, success=None, isex=None,):
9959 
    self.success = success
9960 
    self.isex = isex
9961 
 
9962 
  def read(self, iprot):
9963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9965 
      return
9966 
    iprot.readStructBegin()
9967 
    while True:
9968 
      (fname, ftype, fid) = iprot.readFieldBegin()
9969 
      if ftype == TType.STOP:
9970 
        break
9971 
      if fid == 0:
9972 
        if ftype == TType.LIST:
9973 
          self.success = []
8590 kshitij.so 9974 
          (_etype119, _size116) = iprot.readListBegin()
9975 
          for _i120 in xrange(_size116):
9976 
            _elem121 = Item()
9977 
            _elem121.read(iprot)
9978 
            self.success.append(_elem121)
5944 mandeep.dh 9979 
          iprot.readListEnd()
9980 
        else:
9981 
          iprot.skip(ftype)
9982 
      elif fid == 1:
9983 
        if ftype == TType.STRUCT:
9984 
          self.isex = CatalogServiceException()
9985 
          self.isex.read(iprot)
9986 
        else:
9987 
          iprot.skip(ftype)
9988 
      else:
9989 
        iprot.skip(ftype)
9990 
      iprot.readFieldEnd()
9991 
    iprot.readStructEnd()
9992 
 
9993 
  def write(self, oprot):
9994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9996 
      return
9997 
    oprot.writeStructBegin('getComingSoon_result')
9998 
    if self.success is not None:
9999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10001 
      for iter122 in self.success:
10002 
        iter122.write(oprot)
5944 mandeep.dh 10003 
      oprot.writeListEnd()
10004 
      oprot.writeFieldEnd()
10005 
    if self.isex is not None:
10006 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10007 
      self.isex.write(oprot)
10008 
      oprot.writeFieldEnd()
10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
10012 
  def validate(self):
10013 
    return
10014 
 
10015 
 
10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
10027 
class getComingSoonCatalogIds_args:
10028 
  """
10029 
  Attributes:
10030 
   - beginIndex
10031 
   - totalItems
10032 
   - brand
10033 
   - category
10034 
  """
10035 
 
10036 
  thrift_spec = (
10037 
    None, # 0
10038 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10039 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10040 
    (3, TType.STRING, 'brand', None, None, ), # 3
10041 
    (4, TType.I64, 'category', None, None, ), # 4
10042 
  )
10043 
 
10044 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10045 
    self.beginIndex = beginIndex
10046 
    self.totalItems = totalItems
10047 
    self.brand = brand
10048 
    self.category = category
10049 
 
10050 
  def read(self, iprot):
10051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10053 
      return
10054 
    iprot.readStructBegin()
10055 
    while True:
10056 
      (fname, ftype, fid) = iprot.readFieldBegin()
10057 
      if ftype == TType.STOP:
10058 
        break
10059 
      if fid == 1:
10060 
        if ftype == TType.I64:
10061 
          self.beginIndex = iprot.readI64();
10062 
        else:
10063 
          iprot.skip(ftype)
10064 
      elif fid == 2:
10065 
        if ftype == TType.I64:
10066 
          self.totalItems = iprot.readI64();
10067 
        else:
10068 
          iprot.skip(ftype)
10069 
      elif fid == 3:
10070 
        if ftype == TType.STRING:
10071 
          self.brand = iprot.readString();
10072 
        else:
10073 
          iprot.skip(ftype)
10074 
      elif fid == 4:
10075 
        if ftype == TType.I64:
10076 
          self.category = iprot.readI64();
10077 
        else:
10078 
          iprot.skip(ftype)
10079 
      else:
10080 
        iprot.skip(ftype)
10081 
      iprot.readFieldEnd()
10082 
    iprot.readStructEnd()
10083 
 
10084 
  def write(self, oprot):
10085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10087 
      return
10088 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10089 
    if self.beginIndex is not None:
10090 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10091 
      oprot.writeI64(self.beginIndex)
10092 
      oprot.writeFieldEnd()
10093 
    if self.totalItems is not None:
10094 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10095 
      oprot.writeI64(self.totalItems)
10096 
      oprot.writeFieldEnd()
10097 
    if self.brand is not None:
10098 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10099 
      oprot.writeString(self.brand)
10100 
      oprot.writeFieldEnd()
10101 
    if self.category is not None:
10102 
      oprot.writeFieldBegin('category', TType.I64, 4)
10103 
      oprot.writeI64(self.category)
10104 
      oprot.writeFieldEnd()
10105 
    oprot.writeFieldStop()
10106 
    oprot.writeStructEnd()
10107 
 
10108 
  def validate(self):
10109 
    return
10110 
 
10111 
 
10112 
  def __repr__(self):
10113 
    L = ['%s=%r' % (key, value)
10114 
      for key, value in self.__dict__.iteritems()]
10115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10116 
 
10117 
  def __eq__(self, other):
10118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10119 
 
10120 
  def __ne__(self, other):
10121 
    return not (self == other)
10122 
 
10123 
class getComingSoonCatalogIds_result:
10124 
  """
10125 
  Attributes:
10126 
   - success
10127 
   - cex
10128 
  """
10129 
 
10130 
  thrift_spec = (
10131 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10132 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10133 
  )
10134 
 
10135 
  def __init__(self, success=None, cex=None,):
10136 
    self.success = success
10137 
    self.cex = cex
10138 
 
10139 
  def read(self, iprot):
10140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10142 
      return
10143 
    iprot.readStructBegin()
10144 
    while True:
10145 
      (fname, ftype, fid) = iprot.readFieldBegin()
10146 
      if ftype == TType.STOP:
10147 
        break
10148 
      if fid == 0:
10149 
        if ftype == TType.LIST:
10150 
          self.success = []
8590 kshitij.so 10151 
          (_etype126, _size123) = iprot.readListBegin()
10152 
          for _i127 in xrange(_size123):
10153 
            _elem128 = iprot.readI64();
10154 
            self.success.append(_elem128)
5944 mandeep.dh 10155 
          iprot.readListEnd()
10156 
        else:
10157 
          iprot.skip(ftype)
10158 
      elif fid == 1:
10159 
        if ftype == TType.STRUCT:
10160 
          self.cex = CatalogServiceException()
10161 
          self.cex.read(iprot)
10162 
        else:
10163 
          iprot.skip(ftype)
10164 
      else:
10165 
        iprot.skip(ftype)
10166 
      iprot.readFieldEnd()
10167 
    iprot.readStructEnd()
10168 
 
10169 
  def write(self, oprot):
10170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10172 
      return
10173 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10174 
    if self.success is not None:
10175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10176 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10177 
      for iter129 in self.success:
10178 
        oprot.writeI64(iter129)
5944 mandeep.dh 10179 
      oprot.writeListEnd()
10180 
      oprot.writeFieldEnd()
10181 
    if self.cex is not None:
10182 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10183 
      self.cex.write(oprot)
10184 
      oprot.writeFieldEnd()
10185 
    oprot.writeFieldStop()
10186 
    oprot.writeStructEnd()
10187 
 
10188 
  def validate(self):
10189 
    return
10190 
 
10191 
 
10192 
  def __repr__(self):
10193 
    L = ['%s=%r' % (key, value)
10194 
      for key, value in self.__dict__.iteritems()]
10195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10196 
 
10197 
  def __eq__(self, other):
10198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10199 
 
10200 
  def __ne__(self, other):
10201 
    return not (self == other)
10202 
 
10203 
class getComingSoonCount_args:
10204 
 
10205 
  thrift_spec = (
10206 
  )
10207 
 
10208 
  def read(self, iprot):
10209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10211 
      return
10212 
    iprot.readStructBegin()
10213 
    while True:
10214 
      (fname, ftype, fid) = iprot.readFieldBegin()
10215 
      if ftype == TType.STOP:
10216 
        break
10217 
      else:
10218 
        iprot.skip(ftype)
10219 
      iprot.readFieldEnd()
10220 
    iprot.readStructEnd()
10221 
 
10222 
  def write(self, oprot):
10223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10225 
      return
10226 
    oprot.writeStructBegin('getComingSoonCount_args')
10227 
    oprot.writeFieldStop()
10228 
    oprot.writeStructEnd()
10229 
 
10230 
  def validate(self):
10231 
    return
10232 
 
10233 
 
10234 
  def __repr__(self):
10235 
    L = ['%s=%r' % (key, value)
10236 
      for key, value in self.__dict__.iteritems()]
10237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10238 
 
10239 
  def __eq__(self, other):
10240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10241 
 
10242 
  def __ne__(self, other):
10243 
    return not (self == other)
10244 
 
10245 
class getComingSoonCount_result:
10246 
  """
10247 
  Attributes:
10248 
   - success
10249 
   - cex
10250 
  """
10251 
 
10252 
  thrift_spec = (
10253 
    (0, TType.I64, 'success', None, None, ), # 0
10254 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10255 
  )
10256 
 
10257 
  def __init__(self, success=None, cex=None,):
10258 
    self.success = success
10259 
    self.cex = cex
10260 
 
10261 
  def read(self, iprot):
10262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10264 
      return
10265 
    iprot.readStructBegin()
10266 
    while True:
10267 
      (fname, ftype, fid) = iprot.readFieldBegin()
10268 
      if ftype == TType.STOP:
10269 
        break
10270 
      if fid == 0:
10271 
        if ftype == TType.I64:
10272 
          self.success = iprot.readI64();
10273 
        else:
10274 
          iprot.skip(ftype)
10275 
      elif fid == 1:
10276 
        if ftype == TType.STRUCT:
10277 
          self.cex = CatalogServiceException()
10278 
          self.cex.read(iprot)
10279 
        else:
10280 
          iprot.skip(ftype)
10281 
      else:
10282 
        iprot.skip(ftype)
10283 
      iprot.readFieldEnd()
10284 
    iprot.readStructEnd()
10285 
 
10286 
  def write(self, oprot):
10287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10289 
      return
10290 
    oprot.writeStructBegin('getComingSoonCount_result')
10291 
    if self.success is not None:
10292 
      oprot.writeFieldBegin('success', TType.I64, 0)
10293 
      oprot.writeI64(self.success)
10294 
      oprot.writeFieldEnd()
10295 
    if self.cex is not None:
10296 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10297 
      self.cex.write(oprot)
10298 
      oprot.writeFieldEnd()
10299 
    oprot.writeFieldStop()
10300 
    oprot.writeStructEnd()
10301 
 
10302 
  def validate(self):
10303 
    return
10304 
 
10305 
 
10306 
  def __repr__(self):
10307 
    L = ['%s=%r' % (key, value)
10308 
      for key, value in self.__dict__.iteritems()]
10309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10310 
 
10311 
  def __eq__(self, other):
10312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10313 
 
10314 
  def __ne__(self, other):
10315 
    return not (self == other)
10316 
 
10317 
class getLatestArrivals_args:
10318 
 
10319 
  thrift_spec = (
10320 
  )
10321 
 
10322 
  def read(self, iprot):
10323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10325 
      return
10326 
    iprot.readStructBegin()
10327 
    while True:
10328 
      (fname, ftype, fid) = iprot.readFieldBegin()
10329 
      if ftype == TType.STOP:
10330 
        break
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
10340 
    oprot.writeStructBegin('getLatestArrivals_args')
10341 
    oprot.writeFieldStop()
10342 
    oprot.writeStructEnd()
10343 
 
10344 
  def validate(self):
10345 
    return
10346 
 
10347 
 
10348 
  def __repr__(self):
10349 
    L = ['%s=%r' % (key, value)
10350 
      for key, value in self.__dict__.iteritems()]
10351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10352 
 
10353 
  def __eq__(self, other):
10354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10355 
 
10356 
  def __ne__(self, other):
10357 
    return not (self == other)
10358 
 
10359 
class getLatestArrivals_result:
10360 
  """
10361 
  Attributes:
10362 
   - success
10363 
   - isex
10364 
  """
10365 
 
10366 
  thrift_spec = (
10367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10368 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10369 
  )
10370 
 
10371 
  def __init__(self, success=None, isex=None,):
10372 
    self.success = success
10373 
    self.isex = isex
10374 
 
10375 
  def read(self, iprot):
10376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10378 
      return
10379 
    iprot.readStructBegin()
10380 
    while True:
10381 
      (fname, ftype, fid) = iprot.readFieldBegin()
10382 
      if ftype == TType.STOP:
10383 
        break
10384 
      if fid == 0:
10385 
        if ftype == TType.LIST:
10386 
          self.success = []
8590 kshitij.so 10387 
          (_etype133, _size130) = iprot.readListBegin()
10388 
          for _i134 in xrange(_size130):
10389 
            _elem135 = Item()
10390 
            _elem135.read(iprot)
10391 
            self.success.append(_elem135)
5944 mandeep.dh 10392 
          iprot.readListEnd()
10393 
        else:
10394 
          iprot.skip(ftype)
10395 
      elif fid == 1:
10396 
        if ftype == TType.STRUCT:
10397 
          self.isex = CatalogServiceException()
10398 
          self.isex.read(iprot)
10399 
        else:
10400 
          iprot.skip(ftype)
10401 
      else:
10402 
        iprot.skip(ftype)
10403 
      iprot.readFieldEnd()
10404 
    iprot.readStructEnd()
10405 
 
10406 
  def write(self, oprot):
10407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10409 
      return
10410 
    oprot.writeStructBegin('getLatestArrivals_result')
10411 
    if self.success is not None:
10412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10414 
      for iter136 in self.success:
10415 
        iter136.write(oprot)
5944 mandeep.dh 10416 
      oprot.writeListEnd()
10417 
      oprot.writeFieldEnd()
10418 
    if self.isex is not None:
10419 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10420 
      self.isex.write(oprot)
10421 
      oprot.writeFieldEnd()
10422 
    oprot.writeFieldStop()
10423 
    oprot.writeStructEnd()
10424 
 
10425 
  def validate(self):
10426 
    return
10427 
 
10428 
 
10429 
  def __repr__(self):
10430 
    L = ['%s=%r' % (key, value)
10431 
      for key, value in self.__dict__.iteritems()]
10432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10433 
 
10434 
  def __eq__(self, other):
10435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10436 
 
10437 
  def __ne__(self, other):
10438 
    return not (self == other)
10439 
 
10440 
class getLatestArrivalsCatalogIds_args:
10441 
  """
10442 
  Attributes:
10443 
   - beginIndex
10444 
   - totalItems
10445 
   - brand
10446 
   - categories
10447 
  """
10448 
 
10449 
  thrift_spec = (
10450 
    None, # 0
10451 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10452 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10453 
    (3, TType.STRING, 'brand', None, None, ), # 3
10454 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10455 
  )
10456 
 
10457 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10458 
    self.beginIndex = beginIndex
10459 
    self.totalItems = totalItems
10460 
    self.brand = brand
10461 
    self.categories = categories
10462 
 
10463 
  def read(self, iprot):
10464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10466 
      return
10467 
    iprot.readStructBegin()
10468 
    while True:
10469 
      (fname, ftype, fid) = iprot.readFieldBegin()
10470 
      if ftype == TType.STOP:
10471 
        break
10472 
      if fid == 1:
10473 
        if ftype == TType.I64:
10474 
          self.beginIndex = iprot.readI64();
10475 
        else:
10476 
          iprot.skip(ftype)
10477 
      elif fid == 2:
10478 
        if ftype == TType.I64:
10479 
          self.totalItems = iprot.readI64();
10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      elif fid == 3:
10483 
        if ftype == TType.STRING:
10484 
          self.brand = iprot.readString();
10485 
        else:
10486 
          iprot.skip(ftype)
10487 
      elif fid == 4:
10488 
        if ftype == TType.LIST:
10489 
          self.categories = []
8590 kshitij.so 10490 
          (_etype140, _size137) = iprot.readListBegin()
10491 
          for _i141 in xrange(_size137):
10492 
            _elem142 = iprot.readI64();
10493 
            self.categories.append(_elem142)
5944 mandeep.dh 10494 
          iprot.readListEnd()
10495 
        else:
10496 
          iprot.skip(ftype)
10497 
      else:
10498 
        iprot.skip(ftype)
10499 
      iprot.readFieldEnd()
10500 
    iprot.readStructEnd()
10501 
 
10502 
  def write(self, oprot):
10503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10505 
      return
10506 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10507 
    if self.beginIndex is not None:
10508 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10509 
      oprot.writeI64(self.beginIndex)
10510 
      oprot.writeFieldEnd()
10511 
    if self.totalItems is not None:
10512 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10513 
      oprot.writeI64(self.totalItems)
10514 
      oprot.writeFieldEnd()
10515 
    if self.brand is not None:
10516 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10517 
      oprot.writeString(self.brand)
10518 
      oprot.writeFieldEnd()
10519 
    if self.categories is not None:
10520 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10521 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10522 
      for iter143 in self.categories:
10523 
        oprot.writeI64(iter143)
5944 mandeep.dh 10524 
      oprot.writeListEnd()
10525 
      oprot.writeFieldEnd()
10526 
    oprot.writeFieldStop()
10527 
    oprot.writeStructEnd()
10528 
 
10529 
  def validate(self):
10530 
    return
10531 
 
10532 
 
10533 
  def __repr__(self):
10534 
    L = ['%s=%r' % (key, value)
10535 
      for key, value in self.__dict__.iteritems()]
10536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10537 
 
10538 
  def __eq__(self, other):
10539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10540 
 
10541 
  def __ne__(self, other):
10542 
    return not (self == other)
10543 
 
10544 
class getLatestArrivalsCatalogIds_result:
10545 
  """
10546 
  Attributes:
10547 
   - success
10548 
   - cex
10549 
  """
10550 
 
10551 
  thrift_spec = (
10552 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10553 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10554 
  )
10555 
 
10556 
  def __init__(self, success=None, cex=None,):
10557 
    self.success = success
10558 
    self.cex = cex
10559 
 
10560 
  def read(self, iprot):
10561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10563 
      return
10564 
    iprot.readStructBegin()
10565 
    while True:
10566 
      (fname, ftype, fid) = iprot.readFieldBegin()
10567 
      if ftype == TType.STOP:
10568 
        break
10569 
      if fid == 0:
10570 
        if ftype == TType.LIST:
10571 
          self.success = []
8590 kshitij.so 10572 
          (_etype147, _size144) = iprot.readListBegin()
10573 
          for _i148 in xrange(_size144):
10574 
            _elem149 = iprot.readI64();
10575 
            self.success.append(_elem149)
5944 mandeep.dh 10576 
          iprot.readListEnd()
10577 
        else:
10578 
          iprot.skip(ftype)
10579 
      elif fid == 1:
10580 
        if ftype == TType.STRUCT:
10581 
          self.cex = CatalogServiceException()
10582 
          self.cex.read(iprot)
10583 
        else:
10584 
          iprot.skip(ftype)
10585 
      else:
10586 
        iprot.skip(ftype)
10587 
      iprot.readFieldEnd()
10588 
    iprot.readStructEnd()
10589 
 
10590 
  def write(self, oprot):
10591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10593 
      return
10594 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10595 
    if self.success is not None:
10596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10597 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10598 
      for iter150 in self.success:
10599 
        oprot.writeI64(iter150)
5944 mandeep.dh 10600 
      oprot.writeListEnd()
10601 
      oprot.writeFieldEnd()
10602 
    if self.cex is not None:
10603 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10604 
      self.cex.write(oprot)
10605 
      oprot.writeFieldEnd()
10606 
    oprot.writeFieldStop()
10607 
    oprot.writeStructEnd()
10608 
 
10609 
  def validate(self):
10610 
    return
10611 
 
10612 
 
10613 
  def __repr__(self):
10614 
    L = ['%s=%r' % (key, value)
10615 
      for key, value in self.__dict__.iteritems()]
10616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10617 
 
10618 
  def __eq__(self, other):
10619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10620 
 
10621 
  def __ne__(self, other):
10622 
    return not (self == other)
10623 
 
10624 
class getLatestArrivalsCount_args:
10625 
 
10626 
  thrift_spec = (
10627 
  )
10628 
 
10629 
  def read(self, iprot):
10630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10632 
      return
10633 
    iprot.readStructBegin()
10634 
    while True:
10635 
      (fname, ftype, fid) = iprot.readFieldBegin()
10636 
      if ftype == TType.STOP:
10637 
        break
10638 
      else:
10639 
        iprot.skip(ftype)
10640 
      iprot.readFieldEnd()
10641 
    iprot.readStructEnd()
10642 
 
10643 
  def write(self, oprot):
10644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10646 
      return
10647 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class getLatestArrivalsCount_result:
10667 
  """
10668 
  Attributes:
10669 
   - success
10670 
   - cex
10671 
  """
10672 
 
10673 
  thrift_spec = (
10674 
    (0, TType.I64, 'success', None, None, ), # 0
10675 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10676 
  )
10677 
 
10678 
  def __init__(self, success=None, cex=None,):
10679 
    self.success = success
10680 
    self.cex = cex
10681 
 
10682 
  def read(self, iprot):
10683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10685 
      return
10686 
    iprot.readStructBegin()
10687 
    while True:
10688 
      (fname, ftype, fid) = iprot.readFieldBegin()
10689 
      if ftype == TType.STOP:
10690 
        break
10691 
      if fid == 0:
10692 
        if ftype == TType.I64:
10693 
          self.success = iprot.readI64();
10694 
        else:
10695 
          iprot.skip(ftype)
10696 
      elif fid == 1:
10697 
        if ftype == TType.STRUCT:
10698 
          self.cex = CatalogServiceException()
10699 
          self.cex.read(iprot)
10700 
        else:
10701 
          iprot.skip(ftype)
10702 
      else:
10703 
        iprot.skip(ftype)
10704 
      iprot.readFieldEnd()
10705 
    iprot.readStructEnd()
10706 
 
10707 
  def write(self, oprot):
10708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10710 
      return
10711 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10712 
    if self.success is not None:
10713 
      oprot.writeFieldBegin('success', TType.I64, 0)
10714 
      oprot.writeI64(self.success)
10715 
      oprot.writeFieldEnd()
10716 
    if self.cex is not None:
10717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10718 
      self.cex.write(oprot)
10719 
      oprot.writeFieldEnd()
10720 
    oprot.writeFieldStop()
10721 
    oprot.writeStructEnd()
10722 
 
10723 
  def validate(self):
10724 
    return
10725 
 
10726 
 
10727 
  def __repr__(self):
10728 
    L = ['%s=%r' % (key, value)
10729 
      for key, value in self.__dict__.iteritems()]
10730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10731 
 
10732 
  def __eq__(self, other):
10733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10734 
 
10735 
  def __ne__(self, other):
10736 
    return not (self == other)
10737 
 
10738 
class generateNewEntityID_args:
10739 
 
10740 
  thrift_spec = (
10741 
  )
10742 
 
10743 
  def read(self, iprot):
10744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10746 
      return
10747 
    iprot.readStructBegin()
10748 
    while True:
10749 
      (fname, ftype, fid) = iprot.readFieldBegin()
10750 
      if ftype == TType.STOP:
10751 
        break
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
10761 
    oprot.writeStructBegin('generateNewEntityID_args')
10762 
    oprot.writeFieldStop()
10763 
    oprot.writeStructEnd()
10764 
 
10765 
  def validate(self):
10766 
    return
10767 
 
10768 
 
10769 
  def __repr__(self):
10770 
    L = ['%s=%r' % (key, value)
10771 
      for key, value in self.__dict__.iteritems()]
10772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10773 
 
10774 
  def __eq__(self, other):
10775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10776 
 
10777 
  def __ne__(self, other):
10778 
    return not (self == other)
10779 
 
10780 
class generateNewEntityID_result:
10781 
  """
10782 
  Attributes:
10783 
   - success
10784 
  """
10785 
 
10786 
  thrift_spec = (
10787 
    (0, TType.I64, 'success', None, None, ), # 0
10788 
  )
10789 
 
10790 
  def __init__(self, success=None,):
10791 
    self.success = success
10792 
 
10793 
  def read(self, iprot):
10794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10796 
      return
10797 
    iprot.readStructBegin()
10798 
    while True:
10799 
      (fname, ftype, fid) = iprot.readFieldBegin()
10800 
      if ftype == TType.STOP:
10801 
        break
10802 
      if fid == 0:
10803 
        if ftype == TType.I64:
10804 
          self.success = iprot.readI64();
10805 
        else:
10806 
          iprot.skip(ftype)
10807 
      else:
10808 
        iprot.skip(ftype)
10809 
      iprot.readFieldEnd()
10810 
    iprot.readStructEnd()
10811 
 
10812 
  def write(self, oprot):
10813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10815 
      return
10816 
    oprot.writeStructBegin('generateNewEntityID_result')
10817 
    if self.success is not None:
10818 
      oprot.writeFieldBegin('success', TType.I64, 0)
10819 
      oprot.writeI64(self.success)
10820 
      oprot.writeFieldEnd()
10821 
    oprot.writeFieldStop()
10822 
    oprot.writeStructEnd()
10823 
 
10824 
  def validate(self):
10825 
    return
10826 
 
10827 
 
10828 
  def __repr__(self):
10829 
    L = ['%s=%r' % (key, value)
10830 
      for key, value in self.__dict__.iteritems()]
10831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10832 
 
10833 
  def __eq__(self, other):
10834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10835 
 
10836 
  def __ne__(self, other):
10837 
    return not (self == other)
10838 
 
10839 
class addCategory_args:
10840 
  """
10841 
  Attributes:
10842 
   - category
10843 
  """
10844 
 
10845 
  thrift_spec = (
10846 
    None, # 0
10847 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10848 
  )
10849 
 
10850 
  def __init__(self, category=None,):
10851 
    self.category = category
10852 
 
10853 
  def read(self, iprot):
10854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10856 
      return
10857 
    iprot.readStructBegin()
10858 
    while True:
10859 
      (fname, ftype, fid) = iprot.readFieldBegin()
10860 
      if ftype == TType.STOP:
10861 
        break
10862 
      if fid == 1:
10863 
        if ftype == TType.STRUCT:
10864 
          self.category = Category()
10865 
          self.category.read(iprot)
10866 
        else:
10867 
          iprot.skip(ftype)
10868 
      else:
10869 
        iprot.skip(ftype)
10870 
      iprot.readFieldEnd()
10871 
    iprot.readStructEnd()
10872 
 
10873 
  def write(self, oprot):
10874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10876 
      return
10877 
    oprot.writeStructBegin('addCategory_args')
10878 
    if self.category is not None:
10879 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10880 
      self.category.write(oprot)
10881 
      oprot.writeFieldEnd()
10882 
    oprot.writeFieldStop()
10883 
    oprot.writeStructEnd()
10884 
 
10885 
  def validate(self):
10886 
    return
10887 
 
10888 
 
10889 
  def __repr__(self):
10890 
    L = ['%s=%r' % (key, value)
10891 
      for key, value in self.__dict__.iteritems()]
10892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10893 
 
10894 
  def __eq__(self, other):
10895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10896 
 
10897 
  def __ne__(self, other):
10898 
    return not (self == other)
10899 
 
10900 
class addCategory_result:
10901 
  """
10902 
  Attributes:
10903 
   - success
10904 
  """
10905 
 
10906 
  thrift_spec = (
10907 
    (0, TType.BOOL, 'success', None, None, ), # 0
10908 
  )
10909 
 
10910 
  def __init__(self, success=None,):
10911 
    self.success = success
10912 
 
10913 
  def read(self, iprot):
10914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10916 
      return
10917 
    iprot.readStructBegin()
10918 
    while True:
10919 
      (fname, ftype, fid) = iprot.readFieldBegin()
10920 
      if ftype == TType.STOP:
10921 
        break
10922 
      if fid == 0:
10923 
        if ftype == TType.BOOL:
10924 
          self.success = iprot.readBool();
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      else:
10928 
        iprot.skip(ftype)
10929 
      iprot.readFieldEnd()
10930 
    iprot.readStructEnd()
10931 
 
10932 
  def write(self, oprot):
10933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10935 
      return
10936 
    oprot.writeStructBegin('addCategory_result')
10937 
    if self.success is not None:
10938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10939 
      oprot.writeBool(self.success)
10940 
      oprot.writeFieldEnd()
10941 
    oprot.writeFieldStop()
10942 
    oprot.writeStructEnd()
10943 
 
10944 
  def validate(self):
10945 
    return
10946 
 
10947 
 
10948 
  def __repr__(self):
10949 
    L = ['%s=%r' % (key, value)
10950 
      for key, value in self.__dict__.iteritems()]
10951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10952 
 
10953 
  def __eq__(self, other):
10954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10955 
 
10956 
  def __ne__(self, other):
10957 
    return not (self == other)
10958 
 
10959 
class getCategory_args:
10960 
  """
10961 
  Attributes:
10962 
   - id
10963 
  """
10964 
 
10965 
  thrift_spec = (
10966 
    None, # 0
10967 
    (1, TType.I64, 'id', None, None, ), # 1
10968 
  )
10969 
 
10970 
  def __init__(self, id=None,):
10971 
    self.id = id
10972 
 
10973 
  def read(self, iprot):
10974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10976 
      return
10977 
    iprot.readStructBegin()
10978 
    while True:
10979 
      (fname, ftype, fid) = iprot.readFieldBegin()
10980 
      if ftype == TType.STOP:
10981 
        break
10982 
      if fid == 1:
10983 
        if ftype == TType.I64:
10984 
          self.id = iprot.readI64();
10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      else:
10988 
        iprot.skip(ftype)
10989 
      iprot.readFieldEnd()
10990 
    iprot.readStructEnd()
10991 
 
10992 
  def write(self, oprot):
10993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10995 
      return
10996 
    oprot.writeStructBegin('getCategory_args')
10997 
    if self.id is not None:
10998 
      oprot.writeFieldBegin('id', TType.I64, 1)
10999 
      oprot.writeI64(self.id)
11000 
      oprot.writeFieldEnd()
11001 
    oprot.writeFieldStop()
11002 
    oprot.writeStructEnd()
11003 
 
11004 
  def validate(self):
11005 
    return
11006 
 
11007 
 
11008 
  def __repr__(self):
11009 
    L = ['%s=%r' % (key, value)
11010 
      for key, value in self.__dict__.iteritems()]
11011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11012 
 
11013 
  def __eq__(self, other):
11014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11015 
 
11016 
  def __ne__(self, other):
11017 
    return not (self == other)
11018 
 
11019 
class getCategory_result:
11020 
  """
11021 
  Attributes:
11022 
   - success
11023 
  """
11024 
 
11025 
  thrift_spec = (
11026 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11027 
  )
11028 
 
11029 
  def __init__(self, success=None,):
11030 
    self.success = success
11031 
 
11032 
  def read(self, iprot):
11033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11035 
      return
11036 
    iprot.readStructBegin()
11037 
    while True:
11038 
      (fname, ftype, fid) = iprot.readFieldBegin()
11039 
      if ftype == TType.STOP:
11040 
        break
11041 
      if fid == 0:
11042 
        if ftype == TType.STRUCT:
11043 
          self.success = Category()
11044 
          self.success.read(iprot)
11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      else:
11048 
        iprot.skip(ftype)
11049 
      iprot.readFieldEnd()
11050 
    iprot.readStructEnd()
11051 
 
11052 
  def write(self, oprot):
11053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11055 
      return
11056 
    oprot.writeStructBegin('getCategory_result')
11057 
    if self.success is not None:
11058 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11059 
      self.success.write(oprot)
11060 
      oprot.writeFieldEnd()
11061 
    oprot.writeFieldStop()
11062 
    oprot.writeStructEnd()
11063 
 
11064 
  def validate(self):
11065 
    return
11066 
 
11067 
 
11068 
  def __repr__(self):
11069 
    L = ['%s=%r' % (key, value)
11070 
      for key, value in self.__dict__.iteritems()]
11071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11072 
 
11073 
  def __eq__(self, other):
11074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11075 
 
11076 
  def __ne__(self, other):
11077 
    return not (self == other)
11078 
 
11079 
class getAllCategories_args:
11080 
 
11081 
  thrift_spec = (
11082 
  )
11083 
 
11084 
  def read(self, iprot):
11085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11087 
      return
11088 
    iprot.readStructBegin()
11089 
    while True:
11090 
      (fname, ftype, fid) = iprot.readFieldBegin()
11091 
      if ftype == TType.STOP:
11092 
        break
11093 
      else:
11094 
        iprot.skip(ftype)
11095 
      iprot.readFieldEnd()
11096 
    iprot.readStructEnd()
11097 
 
11098 
  def write(self, oprot):
11099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11101 
      return
11102 
    oprot.writeStructBegin('getAllCategories_args')
11103 
    oprot.writeFieldStop()
11104 
    oprot.writeStructEnd()
11105 
 
11106 
  def validate(self):
11107 
    return
11108 
 
11109 
 
11110 
  def __repr__(self):
11111 
    L = ['%s=%r' % (key, value)
11112 
      for key, value in self.__dict__.iteritems()]
11113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11114 
 
11115 
  def __eq__(self, other):
11116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11117 
 
11118 
  def __ne__(self, other):
11119 
    return not (self == other)
11120 
 
11121 
class getAllCategories_result:
11122 
  """
11123 
  Attributes:
11124 
   - success
11125 
  """
11126 
 
11127 
  thrift_spec = (
11128 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11129 
  )
11130 
 
11131 
  def __init__(self, success=None,):
11132 
    self.success = success
11133 
 
11134 
  def read(self, iprot):
11135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11137 
      return
11138 
    iprot.readStructBegin()
11139 
    while True:
11140 
      (fname, ftype, fid) = iprot.readFieldBegin()
11141 
      if ftype == TType.STOP:
11142 
        break
11143 
      if fid == 0:
11144 
        if ftype == TType.LIST:
11145 
          self.success = []
8590 kshitij.so 11146 
          (_etype154, _size151) = iprot.readListBegin()
11147 
          for _i155 in xrange(_size151):
11148 
            _elem156 = Category()
11149 
            _elem156.read(iprot)
11150 
            self.success.append(_elem156)
5944 mandeep.dh 11151 
          iprot.readListEnd()
11152 
        else:
11153 
          iprot.skip(ftype)
11154 
      else:
11155 
        iprot.skip(ftype)
11156 
      iprot.readFieldEnd()
11157 
    iprot.readStructEnd()
11158 
 
11159 
  def write(self, oprot):
11160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11162 
      return
11163 
    oprot.writeStructBegin('getAllCategories_result')
11164 
    if self.success is not None:
11165 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11166 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11167 
      for iter157 in self.success:
11168 
        iter157.write(oprot)
5944 mandeep.dh 11169 
      oprot.writeListEnd()
11170 
      oprot.writeFieldEnd()
11171 
    oprot.writeFieldStop()
11172 
    oprot.writeStructEnd()
11173 
 
11174 
  def validate(self):
11175 
    return
11176 
 
11177 
 
11178 
  def __repr__(self):
11179 
    L = ['%s=%r' % (key, value)
11180 
      for key, value in self.__dict__.iteritems()]
11181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11182 
 
11183 
  def __eq__(self, other):
11184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11185 
 
11186 
  def __ne__(self, other):
11187 
    return not (self == other)
11188 
 
11189 
class getAllSimilarItems_args:
11190 
  """
11191 
  Attributes:
11192 
   - itemId
11193 
  """
11194 
 
11195 
  thrift_spec = (
11196 
    None, # 0
11197 
    (1, TType.I64, 'itemId', None, None, ), # 1
11198 
  )
11199 
 
11200 
  def __init__(self, itemId=None,):
11201 
    self.itemId = itemId
11202 
 
11203 
  def read(self, iprot):
11204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11206 
      return
11207 
    iprot.readStructBegin()
11208 
    while True:
11209 
      (fname, ftype, fid) = iprot.readFieldBegin()
11210 
      if ftype == TType.STOP:
11211 
        break
11212 
      if fid == 1:
11213 
        if ftype == TType.I64:
11214 
          self.itemId = iprot.readI64();
11215 
        else:
11216 
          iprot.skip(ftype)
11217 
      else:
11218 
        iprot.skip(ftype)
11219 
      iprot.readFieldEnd()
11220 
    iprot.readStructEnd()
11221 
 
11222 
  def write(self, oprot):
11223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11225 
      return
11226 
    oprot.writeStructBegin('getAllSimilarItems_args')
11227 
    if self.itemId is not None:
11228 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11229 
      oprot.writeI64(self.itemId)
11230 
      oprot.writeFieldEnd()
11231 
    oprot.writeFieldStop()
11232 
    oprot.writeStructEnd()
11233 
 
11234 
  def validate(self):
11235 
    return
11236 
 
11237 
 
11238 
  def __repr__(self):
11239 
    L = ['%s=%r' % (key, value)
11240 
      for key, value in self.__dict__.iteritems()]
11241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11242 
 
11243 
  def __eq__(self, other):
11244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11245 
 
11246 
  def __ne__(self, other):
11247 
    return not (self == other)
11248 
 
11249 
class getAllSimilarItems_result:
11250 
  """
11251 
  Attributes:
11252 
   - success
11253 
  """
11254 
 
11255 
  thrift_spec = (
11256 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11257 
  )
11258 
 
11259 
  def __init__(self, success=None,):
11260 
    self.success = success
11261 
 
11262 
  def read(self, iprot):
11263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11265 
      return
11266 
    iprot.readStructBegin()
11267 
    while True:
11268 
      (fname, ftype, fid) = iprot.readFieldBegin()
11269 
      if ftype == TType.STOP:
11270 
        break
11271 
      if fid == 0:
11272 
        if ftype == TType.LIST:
11273 
          self.success = []
8590 kshitij.so 11274 
          (_etype161, _size158) = iprot.readListBegin()
11275 
          for _i162 in xrange(_size158):
11276 
            _elem163 = Item()
11277 
            _elem163.read(iprot)
11278 
            self.success.append(_elem163)
5944 mandeep.dh 11279 
          iprot.readListEnd()
11280 
        else:
11281 
          iprot.skip(ftype)
11282 
      else:
11283 
        iprot.skip(ftype)
11284 
      iprot.readFieldEnd()
11285 
    iprot.readStructEnd()
11286 
 
11287 
  def write(self, oprot):
11288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11290 
      return
11291 
    oprot.writeStructBegin('getAllSimilarItems_result')
11292 
    if self.success is not None:
11293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11295 
      for iter164 in self.success:
11296 
        iter164.write(oprot)
5944 mandeep.dh 11297 
      oprot.writeListEnd()
11298 
      oprot.writeFieldEnd()
11299 
    oprot.writeFieldStop()
11300 
    oprot.writeStructEnd()
11301 
 
11302 
  def validate(self):
11303 
    return
11304 
 
11305 
 
11306 
  def __repr__(self):
11307 
    L = ['%s=%r' % (key, value)
11308 
      for key, value in self.__dict__.iteritems()]
11309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11310 
 
11311 
  def __eq__(self, other):
11312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11313 
 
11314 
  def __ne__(self, other):
11315 
    return not (self == other)
11316 
 
11317 
class addSimilarItem_args:
11318 
  """
11319 
  Attributes:
11320 
   - itemId
11321 
   - catalogItemId
11322 
  """
11323 
 
11324 
  thrift_spec = (
11325 
    None, # 0
11326 
    (1, TType.I64, 'itemId', None, None, ), # 1
11327 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11328 
  )
11329 
 
11330 
  def __init__(self, itemId=None, catalogItemId=None,):
11331 
    self.itemId = itemId
11332 
    self.catalogItemId = catalogItemId
11333 
 
11334 
  def read(self, iprot):
11335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11337 
      return
11338 
    iprot.readStructBegin()
11339 
    while True:
11340 
      (fname, ftype, fid) = iprot.readFieldBegin()
11341 
      if ftype == TType.STOP:
11342 
        break
11343 
      if fid == 1:
11344 
        if ftype == TType.I64:
11345 
          self.itemId = iprot.readI64();
11346 
        else:
11347 
          iprot.skip(ftype)
11348 
      elif fid == 2:
11349 
        if ftype == TType.I64:
11350 
          self.catalogItemId = iprot.readI64();
11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      else:
11354 
        iprot.skip(ftype)
11355 
      iprot.readFieldEnd()
11356 
    iprot.readStructEnd()
11357 
 
11358 
  def write(self, oprot):
11359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11361 
      return
11362 
    oprot.writeStructBegin('addSimilarItem_args')
11363 
    if self.itemId is not None:
11364 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11365 
      oprot.writeI64(self.itemId)
11366 
      oprot.writeFieldEnd()
11367 
    if self.catalogItemId is not None:
11368 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11369 
      oprot.writeI64(self.catalogItemId)
11370 
      oprot.writeFieldEnd()
11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
11389 
class addSimilarItem_result:
11390 
  """
11391 
  Attributes:
11392 
   - success
11393 
   - cex
11394 
  """
11395 
 
11396 
  thrift_spec = (
11397 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11398 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11399 
  )
11400 
 
11401 
  def __init__(self, success=None, cex=None,):
11402 
    self.success = success
11403 
    self.cex = cex
11404 
 
11405 
  def read(self, iprot):
11406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11408 
      return
11409 
    iprot.readStructBegin()
11410 
    while True:
11411 
      (fname, ftype, fid) = iprot.readFieldBegin()
11412 
      if ftype == TType.STOP:
11413 
        break
11414 
      if fid == 0:
11415 
        if ftype == TType.STRUCT:
11416 
          self.success = Item()
11417 
          self.success.read(iprot)
11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      elif fid == 1:
11421 
        if ftype == TType.STRUCT:
11422 
          self.cex = CatalogServiceException()
11423 
          self.cex.read(iprot)
11424 
        else:
11425 
          iprot.skip(ftype)
11426 
      else:
11427 
        iprot.skip(ftype)
11428 
      iprot.readFieldEnd()
11429 
    iprot.readStructEnd()
11430 
 
11431 
  def write(self, oprot):
11432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11434 
      return
11435 
    oprot.writeStructBegin('addSimilarItem_result')
11436 
    if self.success is not None:
11437 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11438 
      self.success.write(oprot)
11439 
      oprot.writeFieldEnd()
11440 
    if self.cex is not None:
11441 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11442 
      self.cex.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 
 
6512 kshitij.so 11462 
class addTag_args:
11463 
  """
11464 
  Attributes:
11465 
   - displayName
11466 
   - itemId
11467 
  """
11468 
 
11469 
  thrift_spec = (
11470 
    None, # 0
11471 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11472 
    (2, TType.I64, 'itemId', None, None, ), # 2
11473 
  )
11474 
 
11475 
  def __init__(self, displayName=None, itemId=None,):
11476 
    self.displayName = displayName
11477 
    self.itemId = itemId
11478 
 
11479 
  def read(self, iprot):
11480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11482 
      return
11483 
    iprot.readStructBegin()
11484 
    while True:
11485 
      (fname, ftype, fid) = iprot.readFieldBegin()
11486 
      if ftype == TType.STOP:
11487 
        break
11488 
      if fid == 1:
11489 
        if ftype == TType.STRING:
11490 
          self.displayName = iprot.readString();
11491 
        else:
11492 
          iprot.skip(ftype)
11493 
      elif fid == 2:
11494 
        if ftype == TType.I64:
11495 
          self.itemId = iprot.readI64();
11496 
        else:
11497 
          iprot.skip(ftype)
11498 
      else:
11499 
        iprot.skip(ftype)
11500 
      iprot.readFieldEnd()
11501 
    iprot.readStructEnd()
11502 
 
11503 
  def write(self, oprot):
11504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11506 
      return
11507 
    oprot.writeStructBegin('addTag_args')
11508 
    if self.displayName is not None:
11509 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11510 
      oprot.writeString(self.displayName)
11511 
      oprot.writeFieldEnd()
11512 
    if self.itemId is not None:
11513 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11514 
      oprot.writeI64(self.itemId)
11515 
      oprot.writeFieldEnd()
11516 
    oprot.writeFieldStop()
11517 
    oprot.writeStructEnd()
11518 
 
11519 
  def validate(self):
11520 
    return
11521 
 
11522 
 
11523 
  def __repr__(self):
11524 
    L = ['%s=%r' % (key, value)
11525 
      for key, value in self.__dict__.iteritems()]
11526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11527 
 
11528 
  def __eq__(self, other):
11529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11530 
 
11531 
  def __ne__(self, other):
11532 
    return not (self == other)
11533 
 
11534 
class addTag_result:
11535 
  """
11536 
  Attributes:
11537 
   - success
11538 
  """
11539 
 
11540 
  thrift_spec = (
11541 
    (0, TType.BOOL, 'success', None, None, ), # 0
11542 
  )
11543 
 
11544 
  def __init__(self, success=None,):
11545 
    self.success = success
11546 
 
11547 
  def read(self, iprot):
11548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11550 
      return
11551 
    iprot.readStructBegin()
11552 
    while True:
11553 
      (fname, ftype, fid) = iprot.readFieldBegin()
11554 
      if ftype == TType.STOP:
11555 
        break
11556 
      if fid == 0:
11557 
        if ftype == TType.BOOL:
11558 
          self.success = iprot.readBool();
11559 
        else:
11560 
          iprot.skip(ftype)
11561 
      else:
11562 
        iprot.skip(ftype)
11563 
      iprot.readFieldEnd()
11564 
    iprot.readStructEnd()
11565 
 
11566 
  def write(self, oprot):
11567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11569 
      return
11570 
    oprot.writeStructBegin('addTag_result')
11571 
    if self.success is not None:
11572 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11573 
      oprot.writeBool(self.success)
11574 
      oprot.writeFieldEnd()
11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
11593 
class deleteEntityTag_args:
11594 
  """
11595 
  Attributes:
11596 
   - displayName
11597 
   - itemId
11598 
  """
11599 
 
11600 
  thrift_spec = (
11601 
    None, # 0
11602 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11603 
    (2, TType.I64, 'itemId', None, None, ), # 2
11604 
  )
11605 
 
11606 
  def __init__(self, displayName=None, itemId=None,):
11607 
    self.displayName = displayName
11608 
    self.itemId = itemId
11609 
 
11610 
  def read(self, iprot):
11611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11613 
      return
11614 
    iprot.readStructBegin()
11615 
    while True:
11616 
      (fname, ftype, fid) = iprot.readFieldBegin()
11617 
      if ftype == TType.STOP:
11618 
        break
11619 
      if fid == 1:
11620 
        if ftype == TType.STRING:
11621 
          self.displayName = iprot.readString();
11622 
        else:
11623 
          iprot.skip(ftype)
11624 
      elif fid == 2:
11625 
        if ftype == TType.I64:
11626 
          self.itemId = iprot.readI64();
11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      else:
11630 
        iprot.skip(ftype)
11631 
      iprot.readFieldEnd()
11632 
    iprot.readStructEnd()
11633 
 
11634 
  def write(self, oprot):
11635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11637 
      return
11638 
    oprot.writeStructBegin('deleteEntityTag_args')
11639 
    if self.displayName is not None:
11640 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11641 
      oprot.writeString(self.displayName)
11642 
      oprot.writeFieldEnd()
11643 
    if self.itemId is not None:
11644 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11645 
      oprot.writeI64(self.itemId)
11646 
      oprot.writeFieldEnd()
11647 
    oprot.writeFieldStop()
11648 
    oprot.writeStructEnd()
11649 
 
11650 
  def validate(self):
11651 
    return
11652 
 
11653 
 
11654 
  def __repr__(self):
11655 
    L = ['%s=%r' % (key, value)
11656 
      for key, value in self.__dict__.iteritems()]
11657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11658 
 
11659 
  def __eq__(self, other):
11660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11661 
 
11662 
  def __ne__(self, other):
11663 
    return not (self == other)
11664 
 
11665 
class deleteEntityTag_result:
11666 
  """
11667 
  Attributes:
11668 
   - success
11669 
  """
11670 
 
11671 
  thrift_spec = (
11672 
    (0, TType.BOOL, 'success', None, None, ), # 0
11673 
  )
11674 
 
11675 
  def __init__(self, success=None,):
11676 
    self.success = success
11677 
 
11678 
  def read(self, iprot):
11679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11681 
      return
11682 
    iprot.readStructBegin()
11683 
    while True:
11684 
      (fname, ftype, fid) = iprot.readFieldBegin()
11685 
      if ftype == TType.STOP:
11686 
        break
11687 
      if fid == 0:
11688 
        if ftype == TType.BOOL:
11689 
          self.success = iprot.readBool();
11690 
        else:
11691 
          iprot.skip(ftype)
11692 
      else:
11693 
        iprot.skip(ftype)
11694 
      iprot.readFieldEnd()
11695 
    iprot.readStructEnd()
11696 
 
11697 
  def write(self, oprot):
11698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11700 
      return
11701 
    oprot.writeStructBegin('deleteEntityTag_result')
11702 
    if self.success is not None:
11703 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11704 
      oprot.writeBool(self.success)
11705 
      oprot.writeFieldEnd()
11706 
    oprot.writeFieldStop()
11707 
    oprot.writeStructEnd()
11708 
 
11709 
  def validate(self):
11710 
    return
11711 
 
11712 
 
11713 
  def __repr__(self):
11714 
    L = ['%s=%r' % (key, value)
11715 
      for key, value in self.__dict__.iteritems()]
11716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11717 
 
11718 
  def __eq__(self, other):
11719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11720 
 
11721 
  def __ne__(self, other):
11722 
    return not (self == other)
11723 
 
11724 
class deleteTag_args:
11725 
  """
11726 
  Attributes:
11727 
   - displayName
11728 
  """
11729 
 
11730 
  thrift_spec = (
11731 
    None, # 0
11732 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11733 
  )
11734 
 
11735 
  def __init__(self, displayName=None,):
11736 
    self.displayName = displayName
11737 
 
11738 
  def read(self, iprot):
11739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11741 
      return
11742 
    iprot.readStructBegin()
11743 
    while True:
11744 
      (fname, ftype, fid) = iprot.readFieldBegin()
11745 
      if ftype == TType.STOP:
11746 
        break
11747 
      if fid == 1:
11748 
        if ftype == TType.STRING:
11749 
          self.displayName = iprot.readString();
11750 
        else:
11751 
          iprot.skip(ftype)
11752 
      else:
11753 
        iprot.skip(ftype)
11754 
      iprot.readFieldEnd()
11755 
    iprot.readStructEnd()
11756 
 
11757 
  def write(self, oprot):
11758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11760 
      return
11761 
    oprot.writeStructBegin('deleteTag_args')
11762 
    if self.displayName is not None:
11763 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11764 
      oprot.writeString(self.displayName)
11765 
      oprot.writeFieldEnd()
11766 
    oprot.writeFieldStop()
11767 
    oprot.writeStructEnd()
11768 
 
11769 
  def validate(self):
11770 
    return
11771 
 
11772 
 
11773 
  def __repr__(self):
11774 
    L = ['%s=%r' % (key, value)
11775 
      for key, value in self.__dict__.iteritems()]
11776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11777 
 
11778 
  def __eq__(self, other):
11779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11780 
 
11781 
  def __ne__(self, other):
11782 
    return not (self == other)
11783 
 
11784 
class deleteTag_result:
11785 
  """
11786 
  Attributes:
11787 
   - success
11788 
  """
11789 
 
11790 
  thrift_spec = (
11791 
    (0, TType.BOOL, 'success', None, None, ), # 0
11792 
  )
11793 
 
11794 
  def __init__(self, success=None,):
11795 
    self.success = success
11796 
 
11797 
  def read(self, iprot):
11798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11800 
      return
11801 
    iprot.readStructBegin()
11802 
    while True:
11803 
      (fname, ftype, fid) = iprot.readFieldBegin()
11804 
      if ftype == TType.STOP:
11805 
        break
11806 
      if fid == 0:
11807 
        if ftype == TType.BOOL:
11808 
          self.success = iprot.readBool();
11809 
        else:
11810 
          iprot.skip(ftype)
11811 
      else:
11812 
        iprot.skip(ftype)
11813 
      iprot.readFieldEnd()
11814 
    iprot.readStructEnd()
11815 
 
11816 
  def write(self, oprot):
11817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11819 
      return
11820 
    oprot.writeStructBegin('deleteTag_result')
11821 
    if self.success is not None:
11822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11823 
      oprot.writeBool(self.success)
11824 
      oprot.writeFieldEnd()
11825 
    oprot.writeFieldStop()
11826 
    oprot.writeStructEnd()
11827 
 
11828 
  def validate(self):
11829 
    return
11830 
 
11831 
 
11832 
  def __repr__(self):
11833 
    L = ['%s=%r' % (key, value)
11834 
      for key, value in self.__dict__.iteritems()]
11835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11836 
 
11837 
  def __eq__(self, other):
11838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11839 
 
11840 
  def __ne__(self, other):
11841 
    return not (self == other)
11842 
 
11843 
class getAllTags_args:
11844 
 
11845 
  thrift_spec = (
11846 
  )
11847 
 
11848 
  def read(self, iprot):
11849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11851 
      return
11852 
    iprot.readStructBegin()
11853 
    while True:
11854 
      (fname, ftype, fid) = iprot.readFieldBegin()
11855 
      if ftype == TType.STOP:
11856 
        break
11857 
      else:
11858 
        iprot.skip(ftype)
11859 
      iprot.readFieldEnd()
11860 
    iprot.readStructEnd()
11861 
 
11862 
  def write(self, oprot):
11863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11865 
      return
11866 
    oprot.writeStructBegin('getAllTags_args')
11867 
    oprot.writeFieldStop()
11868 
    oprot.writeStructEnd()
11869 
 
11870 
  def validate(self):
11871 
    return
11872 
 
11873 
 
11874 
  def __repr__(self):
11875 
    L = ['%s=%r' % (key, value)
11876 
      for key, value in self.__dict__.iteritems()]
11877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11878 
 
11879 
  def __eq__(self, other):
11880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11881 
 
11882 
  def __ne__(self, other):
11883 
    return not (self == other)
11884 
 
11885 
class getAllTags_result:
11886 
  """
11887 
  Attributes:
11888 
   - success
11889 
  """
11890 
 
11891 
  thrift_spec = (
11892 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11893 
  )
11894 
 
11895 
  def __init__(self, success=None,):
11896 
    self.success = success
11897 
 
11898 
  def read(self, iprot):
11899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11901 
      return
11902 
    iprot.readStructBegin()
11903 
    while True:
11904 
      (fname, ftype, fid) = iprot.readFieldBegin()
11905 
      if ftype == TType.STOP:
11906 
        break
11907 
      if fid == 0:
11908 
        if ftype == TType.LIST:
11909 
          self.success = []
8590 kshitij.so 11910 
          (_etype168, _size165) = iprot.readListBegin()
11911 
          for _i169 in xrange(_size165):
11912 
            _elem170 = iprot.readString();
11913 
            self.success.append(_elem170)
6512 kshitij.so 11914 
          iprot.readListEnd()
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      else:
11918 
        iprot.skip(ftype)
11919 
      iprot.readFieldEnd()
11920 
    iprot.readStructEnd()
11921 
 
11922 
  def write(self, oprot):
11923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11925 
      return
11926 
    oprot.writeStructBegin('getAllTags_result')
11927 
    if self.success is not None:
11928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11929 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11930 
      for iter171 in self.success:
11931 
        oprot.writeString(iter171)
6512 kshitij.so 11932 
      oprot.writeListEnd()
11933 
      oprot.writeFieldEnd()
11934 
    oprot.writeFieldStop()
11935 
    oprot.writeStructEnd()
11936 
 
11937 
  def validate(self):
11938 
    return
11939 
 
11940 
 
11941 
  def __repr__(self):
11942 
    L = ['%s=%r' % (key, value)
11943 
      for key, value in self.__dict__.iteritems()]
11944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11945 
 
11946 
  def __eq__(self, other):
11947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11948 
 
11949 
  def __ne__(self, other):
11950 
    return not (self == other)
11951 
 
11952 
class getAllEntitiesByTagName_args:
11953 
  """
11954 
  Attributes:
11955 
   - displayName
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    None, # 0
11960 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11961 
  )
11962 
 
11963 
  def __init__(self, displayName=None,):
11964 
    self.displayName = displayName
11965 
 
11966 
  def read(self, iprot):
11967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11969 
      return
11970 
    iprot.readStructBegin()
11971 
    while True:
11972 
      (fname, ftype, fid) = iprot.readFieldBegin()
11973 
      if ftype == TType.STOP:
11974 
        break
11975 
      if fid == 1:
11976 
        if ftype == TType.STRING:
11977 
          self.displayName = iprot.readString();
11978 
        else:
11979 
          iprot.skip(ftype)
11980 
      else:
11981 
        iprot.skip(ftype)
11982 
      iprot.readFieldEnd()
11983 
    iprot.readStructEnd()
11984 
 
11985 
  def write(self, oprot):
11986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11988 
      return
11989 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11990 
    if self.displayName is not None:
11991 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11992 
      oprot.writeString(self.displayName)
11993 
      oprot.writeFieldEnd()
11994 
    oprot.writeFieldStop()
11995 
    oprot.writeStructEnd()
11996 
 
11997 
  def validate(self):
11998 
    return
11999 
 
12000 
 
12001 
  def __repr__(self):
12002 
    L = ['%s=%r' % (key, value)
12003 
      for key, value in self.__dict__.iteritems()]
12004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12005 
 
12006 
  def __eq__(self, other):
12007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12008 
 
12009 
  def __ne__(self, other):
12010 
    return not (self == other)
12011 
 
12012 
class getAllEntitiesByTagName_result:
12013 
  """
12014 
  Attributes:
12015 
   - success
12016 
  """
12017 
 
12018 
  thrift_spec = (
12019 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12020 
  )
12021 
 
12022 
  def __init__(self, success=None,):
12023 
    self.success = success
12024 
 
12025 
  def read(self, iprot):
12026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12028 
      return
12029 
    iprot.readStructBegin()
12030 
    while True:
12031 
      (fname, ftype, fid) = iprot.readFieldBegin()
12032 
      if ftype == TType.STOP:
12033 
        break
12034 
      if fid == 0:
12035 
        if ftype == TType.LIST:
12036 
          self.success = []
8590 kshitij.so 12037 
          (_etype175, _size172) = iprot.readListBegin()
12038 
          for _i176 in xrange(_size172):
12039 
            _elem177 = iprot.readI64();
12040 
            self.success.append(_elem177)
6512 kshitij.so 12041 
          iprot.readListEnd()
12042 
        else:
12043 
          iprot.skip(ftype)
12044 
      else:
12045 
        iprot.skip(ftype)
12046 
      iprot.readFieldEnd()
12047 
    iprot.readStructEnd()
12048 
 
12049 
  def write(self, oprot):
12050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12052 
      return
12053 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12054 
    if self.success is not None:
12055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12056 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12057 
      for iter178 in self.success:
12058 
        oprot.writeI64(iter178)
6512 kshitij.so 12059 
      oprot.writeListEnd()
12060 
      oprot.writeFieldEnd()
12061 
    oprot.writeFieldStop()
12062 
    oprot.writeStructEnd()
12063 
 
12064 
  def validate(self):
12065 
    return
12066 
 
12067 
 
12068 
  def __repr__(self):
12069 
    L = ['%s=%r' % (key, value)
12070 
      for key, value in self.__dict__.iteritems()]
12071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12072 
 
12073 
  def __eq__(self, other):
12074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12075 
 
12076 
  def __ne__(self, other):
12077 
    return not (self == other)
12078 
 
6845 amit.gupta 12079 
class getAllEntityTags_args:
12080 
 
12081 
  thrift_spec = (
12082 
  )
12083 
 
12084 
  def read(self, iprot):
12085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12087 
      return
12088 
    iprot.readStructBegin()
12089 
    while True:
12090 
      (fname, ftype, fid) = iprot.readFieldBegin()
12091 
      if ftype == TType.STOP:
12092 
        break
12093 
      else:
12094 
        iprot.skip(ftype)
12095 
      iprot.readFieldEnd()
12096 
    iprot.readStructEnd()
12097 
 
12098 
  def write(self, oprot):
12099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12101 
      return
12102 
    oprot.writeStructBegin('getAllEntityTags_args')
12103 
    oprot.writeFieldStop()
12104 
    oprot.writeStructEnd()
12105 
 
12106 
  def validate(self):
12107 
    return
12108 
 
12109 
 
12110 
  def __repr__(self):
12111 
    L = ['%s=%r' % (key, value)
12112 
      for key, value in self.__dict__.iteritems()]
12113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12114 
 
12115 
  def __eq__(self, other):
12116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12117 
 
12118 
  def __ne__(self, other):
12119 
    return not (self == other)
12120 
 
12121 
class getAllEntityTags_result:
12122 
  """
12123 
  Attributes:
12124 
   - success
12125 
  """
12126 
 
12127 
  thrift_spec = (
12128 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12129 
  )
12130 
 
12131 
  def __init__(self, success=None,):
12132 
    self.success = success
12133 
 
12134 
  def read(self, iprot):
12135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12137 
      return
12138 
    iprot.readStructBegin()
12139 
    while True:
12140 
      (fname, ftype, fid) = iprot.readFieldBegin()
12141 
      if ftype == TType.STOP:
12142 
        break
12143 
      if fid == 0:
12144 
        if ftype == TType.MAP:
12145 
          self.success = {}
8590 kshitij.so 12146 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12147 
          for _i183 in xrange(_size179):
12148 
            _key184 = iprot.readI64();
12149 
            _val185 = []
12150 
            (_etype189, _size186) = iprot.readListBegin()
12151 
            for _i190 in xrange(_size186):
12152 
              _elem191 = iprot.readString();
12153 
              _val185.append(_elem191)
6845 amit.gupta 12154 
            iprot.readListEnd()
8590 kshitij.so 12155 
            self.success[_key184] = _val185
6845 amit.gupta 12156 
          iprot.readMapEnd()
12157 
        else:
12158 
          iprot.skip(ftype)
12159 
      else:
12160 
        iprot.skip(ftype)
12161 
      iprot.readFieldEnd()
12162 
    iprot.readStructEnd()
12163 
 
12164 
  def write(self, oprot):
12165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12167 
      return
12168 
    oprot.writeStructBegin('getAllEntityTags_result')
12169 
    if self.success is not None:
12170 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12171 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12172 
      for kiter192,viter193 in self.success.items():
12173 
        oprot.writeI64(kiter192)
12174 
        oprot.writeListBegin(TType.STRING, len(viter193))
12175 
        for iter194 in viter193:
12176 
          oprot.writeString(iter194)
6845 amit.gupta 12177 
        oprot.writeListEnd()
12178 
      oprot.writeMapEnd()
12179 
      oprot.writeFieldEnd()
12180 
    oprot.writeFieldStop()
12181 
    oprot.writeStructEnd()
12182 
 
12183 
  def validate(self):
12184 
    return
12185 
 
12186 
 
12187 
  def __repr__(self):
12188 
    L = ['%s=%r' % (key, value)
12189 
      for key, value in self.__dict__.iteritems()]
12190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12191 
 
12192 
  def __eq__(self, other):
12193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12194 
 
12195 
  def __ne__(self, other):
12196 
    return not (self == other)
12197 
 
6850 kshitij.so 12198 
class addBanner_args:
12199 
  """
12200 
  Attributes:
8590 kshitij.so 12201 
   - bannerCongregate
6850 kshitij.so 12202 
  """
12203 
 
12204 
  thrift_spec = (
12205 
    None, # 0
8590 kshitij.so 12206 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12207 
  )
12208 
 
8590 kshitij.so 12209 
  def __init__(self, bannerCongregate=None,):
12210 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12211 
 
12212 
  def read(self, iprot):
12213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12215 
      return
12216 
    iprot.readStructBegin()
12217 
    while True:
12218 
      (fname, ftype, fid) = iprot.readFieldBegin()
12219 
      if ftype == TType.STOP:
12220 
        break
12221 
      if fid == 1:
8579 kshitij.so 12222 
        if ftype == TType.STRUCT:
8590 kshitij.so 12223 
          self.bannerCongregate = BannerCongregate()
12224 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12225 
        else:
12226 
          iprot.skip(ftype)
8579 kshitij.so 12227 
      else:
12228 
        iprot.skip(ftype)
12229 
      iprot.readFieldEnd()
12230 
    iprot.readStructEnd()
12231 
 
12232 
  def write(self, oprot):
12233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12235 
      return
12236 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12237 
    if self.bannerCongregate is not None:
12238 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12239 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12240 
      oprot.writeFieldEnd()
12241 
    oprot.writeFieldStop()
12242 
    oprot.writeStructEnd()
12243 
 
12244 
  def validate(self):
12245 
    return
12246 
 
12247 
 
12248 
  def __repr__(self):
12249 
    L = ['%s=%r' % (key, value)
12250 
      for key, value in self.__dict__.iteritems()]
12251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12252 
 
12253 
  def __eq__(self, other):
12254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12255 
 
12256 
  def __ne__(self, other):
12257 
    return not (self == other)
12258 
 
12259 
class addBanner_result:
12260 
 
12261 
  thrift_spec = (
12262 
  )
12263 
 
12264 
  def read(self, iprot):
12265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12267 
      return
12268 
    iprot.readStructBegin()
12269 
    while True:
12270 
      (fname, ftype, fid) = iprot.readFieldBegin()
12271 
      if ftype == TType.STOP:
12272 
        break
12273 
      else:
12274 
        iprot.skip(ftype)
12275 
      iprot.readFieldEnd()
12276 
    iprot.readStructEnd()
12277 
 
12278 
  def write(self, oprot):
12279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12281 
      return
12282 
    oprot.writeStructBegin('addBanner_result')
12283 
    oprot.writeFieldStop()
12284 
    oprot.writeStructEnd()
12285 
 
12286 
  def validate(self):
12287 
    return
12288 
 
12289 
 
12290 
  def __repr__(self):
12291 
    L = ['%s=%r' % (key, value)
12292 
      for key, value in self.__dict__.iteritems()]
12293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12294 
 
12295 
  def __eq__(self, other):
12296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12297 
 
12298 
  def __ne__(self, other):
12299 
    return not (self == other)
12300 
 
12301 
class updateBanner_args:
12302 
  """
12303 
  Attributes:
12304 
   - banner
12305 
  """
12306 
 
12307 
  thrift_spec = (
12308 
    None, # 0
12309 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12310 
  )
12311 
 
12312 
  def __init__(self, banner=None,):
12313 
    self.banner = banner
12314 
 
12315 
  def read(self, iprot):
12316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12318 
      return
12319 
    iprot.readStructBegin()
12320 
    while True:
12321 
      (fname, ftype, fid) = iprot.readFieldBegin()
12322 
      if ftype == TType.STOP:
12323 
        break
12324 
      if fid == 1:
12325 
        if ftype == TType.STRUCT:
12326 
          self.banner = Banner()
12327 
          self.banner.read(iprot)
6850 kshitij.so 12328 
        else:
12329 
          iprot.skip(ftype)
12330 
      else:
12331 
        iprot.skip(ftype)
12332 
      iprot.readFieldEnd()
12333 
    iprot.readStructEnd()
12334 
 
12335 
  def write(self, oprot):
12336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12338 
      return
8579 kshitij.so 12339 
    oprot.writeStructBegin('updateBanner_args')
12340 
    if self.banner is not None:
12341 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12342 
      self.banner.write(oprot)
6850 kshitij.so 12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
12347 
  def validate(self):
12348 
    return
12349 
 
12350 
 
12351 
  def __repr__(self):
12352 
    L = ['%s=%r' % (key, value)
12353 
      for key, value in self.__dict__.iteritems()]
12354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12355 
 
12356 
  def __eq__(self, other):
12357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12358 
 
12359 
  def __ne__(self, other):
12360 
    return not (self == other)
12361 
 
8579 kshitij.so 12362 
class updateBanner_result:
6850 kshitij.so 12363 
  """
12364 
  Attributes:
12365 
   - success
12366 
  """
12367 
 
12368 
  thrift_spec = (
12369 
    (0, TType.BOOL, 'success', None, None, ), # 0
12370 
  )
12371 
 
12372 
  def __init__(self, success=None,):
12373 
    self.success = success
12374 
 
12375 
  def read(self, iprot):
12376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12378 
      return
12379 
    iprot.readStructBegin()
12380 
    while True:
12381 
      (fname, ftype, fid) = iprot.readFieldBegin()
12382 
      if ftype == TType.STOP:
12383 
        break
12384 
      if fid == 0:
12385 
        if ftype == TType.BOOL:
12386 
          self.success = iprot.readBool();
12387 
        else:
12388 
          iprot.skip(ftype)
12389 
      else:
12390 
        iprot.skip(ftype)
12391 
      iprot.readFieldEnd()
12392 
    iprot.readStructEnd()
12393 
 
12394 
  def write(self, oprot):
12395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12397 
      return
8579 kshitij.so 12398 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12399 
    if self.success is not None:
12400 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12401 
      oprot.writeBool(self.success)
12402 
      oprot.writeFieldEnd()
12403 
    oprot.writeFieldStop()
12404 
    oprot.writeStructEnd()
12405 
 
12406 
  def validate(self):
12407 
    return
12408 
 
12409 
 
12410 
  def __repr__(self):
12411 
    L = ['%s=%r' % (key, value)
12412 
      for key, value in self.__dict__.iteritems()]
12413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12414 
 
12415 
  def __eq__(self, other):
12416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12417 
 
12418 
  def __ne__(self, other):
12419 
    return not (self == other)
12420 
 
12421 
class getAllBanners_args:
12422 
 
12423 
  thrift_spec = (
12424 
  )
12425 
 
12426 
  def read(self, iprot):
12427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12429 
      return
12430 
    iprot.readStructBegin()
12431 
    while True:
12432 
      (fname, ftype, fid) = iprot.readFieldBegin()
12433 
      if ftype == TType.STOP:
12434 
        break
12435 
      else:
12436 
        iprot.skip(ftype)
12437 
      iprot.readFieldEnd()
12438 
    iprot.readStructEnd()
12439 
 
12440 
  def write(self, oprot):
12441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12443 
      return
12444 
    oprot.writeStructBegin('getAllBanners_args')
12445 
    oprot.writeFieldStop()
12446 
    oprot.writeStructEnd()
12447 
 
12448 
  def validate(self):
12449 
    return
12450 
 
12451 
 
12452 
  def __repr__(self):
12453 
    L = ['%s=%r' % (key, value)
12454 
      for key, value in self.__dict__.iteritems()]
12455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12456 
 
12457 
  def __eq__(self, other):
12458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12459 
 
12460 
  def __ne__(self, other):
12461 
    return not (self == other)
12462 
 
12463 
class getAllBanners_result:
12464 
  """
12465 
  Attributes:
12466 
   - success
12467 
  """
12468 
 
12469 
  thrift_spec = (
8579 kshitij.so 12470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12471 
  )
12472 
 
12473 
  def __init__(self, success=None,):
12474 
    self.success = success
12475 
 
12476 
  def read(self, iprot):
12477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12479 
      return
12480 
    iprot.readStructBegin()
12481 
    while True:
12482 
      (fname, ftype, fid) = iprot.readFieldBegin()
12483 
      if ftype == TType.STOP:
12484 
        break
12485 
      if fid == 0:
12486 
        if ftype == TType.LIST:
12487 
          self.success = []
8590 kshitij.so 12488 
          (_etype198, _size195) = iprot.readListBegin()
12489 
          for _i199 in xrange(_size195):
12490 
            _elem200 = Banner()
12491 
            _elem200.read(iprot)
12492 
            self.success.append(_elem200)
6850 kshitij.so 12493 
          iprot.readListEnd()
12494 
        else:
12495 
          iprot.skip(ftype)
12496 
      else:
12497 
        iprot.skip(ftype)
12498 
      iprot.readFieldEnd()
12499 
    iprot.readStructEnd()
12500 
 
12501 
  def write(self, oprot):
12502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12504 
      return
12505 
    oprot.writeStructBegin('getAllBanners_result')
12506 
    if self.success is not None:
12507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12509 
      for iter201 in self.success:
12510 
        iter201.write(oprot)
6850 kshitij.so 12511 
      oprot.writeListEnd()
12512 
      oprot.writeFieldEnd()
12513 
    oprot.writeFieldStop()
12514 
    oprot.writeStructEnd()
12515 
 
12516 
  def validate(self):
12517 
    return
12518 
 
12519 
 
12520 
  def __repr__(self):
12521 
    L = ['%s=%r' % (key, value)
12522 
      for key, value in self.__dict__.iteritems()]
12523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12524 
 
12525 
  def __eq__(self, other):
12526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12527 
 
12528 
  def __ne__(self, other):
12529 
    return not (self == other)
12530 
 
12531 
class deleteBanner_args:
12532 
  """
12533 
  Attributes:
12534 
   - bannerName
9155 kshitij.so 12535 
   - bannerType
6850 kshitij.so 12536 
  """
12537 
 
12538 
  thrift_spec = (
12539 
    None, # 0
12540 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12541 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12542 
  )
12543 
 
9155 kshitij.so 12544 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12545 
    self.bannerName = bannerName
9155 kshitij.so 12546 
    self.bannerType = bannerType
6850 kshitij.so 12547 
 
12548 
  def read(self, iprot):
12549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12551 
      return
12552 
    iprot.readStructBegin()
12553 
    while True:
12554 
      (fname, ftype, fid) = iprot.readFieldBegin()
12555 
      if ftype == TType.STOP:
12556 
        break
12557 
      if fid == 1:
12558 
        if ftype == TType.STRING:
12559 
          self.bannerName = iprot.readString();
12560 
        else:
12561 
          iprot.skip(ftype)
9155 kshitij.so 12562 
      elif fid == 2:
12563 
        if ftype == TType.I32:
12564 
          self.bannerType = iprot.readI32();
12565 
        else:
12566 
          iprot.skip(ftype)
6850 kshitij.so 12567 
      else:
12568 
        iprot.skip(ftype)
12569 
      iprot.readFieldEnd()
12570 
    iprot.readStructEnd()
12571 
 
12572 
  def write(self, oprot):
12573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12575 
      return
12576 
    oprot.writeStructBegin('deleteBanner_args')
12577 
    if self.bannerName is not None:
12578 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12579 
      oprot.writeString(self.bannerName)
12580 
      oprot.writeFieldEnd()
9155 kshitij.so 12581 
    if self.bannerType is not None:
12582 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12583 
      oprot.writeI32(self.bannerType)
12584 
      oprot.writeFieldEnd()
6850 kshitij.so 12585 
    oprot.writeFieldStop()
12586 
    oprot.writeStructEnd()
12587 
 
12588 
  def validate(self):
12589 
    return
12590 
 
12591 
 
12592 
  def __repr__(self):
12593 
    L = ['%s=%r' % (key, value)
12594 
      for key, value in self.__dict__.iteritems()]
12595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12596 
 
12597 
  def __eq__(self, other):
12598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12599 
 
12600 
  def __ne__(self, other):
12601 
    return not (self == other)
12602 
 
12603 
class deleteBanner_result:
12604 
  """
12605 
  Attributes:
12606 
   - success
12607 
  """
12608 
 
12609 
  thrift_spec = (
12610 
    (0, TType.BOOL, 'success', None, None, ), # 0
12611 
  )
12612 
 
12613 
  def __init__(self, success=None,):
12614 
    self.success = success
12615 
 
12616 
  def read(self, iprot):
12617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12619 
      return
12620 
    iprot.readStructBegin()
12621 
    while True:
12622 
      (fname, ftype, fid) = iprot.readFieldBegin()
12623 
      if ftype == TType.STOP:
12624 
        break
12625 
      if fid == 0:
12626 
        if ftype == TType.BOOL:
12627 
          self.success = iprot.readBool();
12628 
        else:
12629 
          iprot.skip(ftype)
12630 
      else:
12631 
        iprot.skip(ftype)
12632 
      iprot.readFieldEnd()
12633 
    iprot.readStructEnd()
12634 
 
12635 
  def write(self, oprot):
12636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12638 
      return
12639 
    oprot.writeStructBegin('deleteBanner_result')
12640 
    if self.success is not None:
12641 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12642 
      oprot.writeBool(self.success)
12643 
      oprot.writeFieldEnd()
12644 
    oprot.writeFieldStop()
12645 
    oprot.writeStructEnd()
12646 
 
12647 
  def validate(self):
12648 
    return
12649 
 
12650 
 
12651 
  def __repr__(self):
12652 
    L = ['%s=%r' % (key, value)
12653 
      for key, value in self.__dict__.iteritems()]
12654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12655 
 
12656 
  def __eq__(self, other):
12657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12658 
 
12659 
  def __ne__(self, other):
12660 
    return not (self == other)
12661 
 
12662 
class getBannerDetails_args:
12663 
  """
12664 
  Attributes:
12665 
   - bannerName
9155 kshitij.so 12666 
   - bannerType
6850 kshitij.so 12667 
  """
12668 
 
12669 
  thrift_spec = (
12670 
    None, # 0
12671 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12672 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12673 
  )
12674 
 
9155 kshitij.so 12675 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12676 
    self.bannerName = bannerName
9155 kshitij.so 12677 
    self.bannerType = bannerType
6850 kshitij.so 12678 
 
12679 
  def read(self, iprot):
12680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12682 
      return
12683 
    iprot.readStructBegin()
12684 
    while True:
12685 
      (fname, ftype, fid) = iprot.readFieldBegin()
12686 
      if ftype == TType.STOP:
12687 
        break
12688 
      if fid == 1:
12689 
        if ftype == TType.STRING:
12690 
          self.bannerName = iprot.readString();
12691 
        else:
12692 
          iprot.skip(ftype)
9155 kshitij.so 12693 
      elif fid == 2:
12694 
        if ftype == TType.I32:
12695 
          self.bannerType = iprot.readI32();
12696 
        else:
12697 
          iprot.skip(ftype)
6850 kshitij.so 12698 
      else:
12699 
        iprot.skip(ftype)
12700 
      iprot.readFieldEnd()
12701 
    iprot.readStructEnd()
12702 
 
12703 
  def write(self, oprot):
12704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12706 
      return
12707 
    oprot.writeStructBegin('getBannerDetails_args')
12708 
    if self.bannerName is not None:
12709 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12710 
      oprot.writeString(self.bannerName)
12711 
      oprot.writeFieldEnd()
9155 kshitij.so 12712 
    if self.bannerType is not None:
12713 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12714 
      oprot.writeI32(self.bannerType)
12715 
      oprot.writeFieldEnd()
6850 kshitij.so 12716 
    oprot.writeFieldStop()
12717 
    oprot.writeStructEnd()
12718 
 
12719 
  def validate(self):
12720 
    return
12721 
 
12722 
 
12723 
  def __repr__(self):
12724 
    L = ['%s=%r' % (key, value)
12725 
      for key, value in self.__dict__.iteritems()]
12726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12727 
 
12728 
  def __eq__(self, other):
12729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12730 
 
12731 
  def __ne__(self, other):
12732 
    return not (self == other)
12733 
 
12734 
class getBannerDetails_result:
12735 
  """
12736 
  Attributes:
12737 
   - success
12738 
  """
12739 
 
12740 
  thrift_spec = (
12741 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12742 
  )
12743 
 
12744 
  def __init__(self, success=None,):
12745 
    self.success = success
12746 
 
12747 
  def read(self, iprot):
12748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12750 
      return
12751 
    iprot.readStructBegin()
12752 
    while True:
12753 
      (fname, ftype, fid) = iprot.readFieldBegin()
12754 
      if ftype == TType.STOP:
12755 
        break
12756 
      if fid == 0:
12757 
        if ftype == TType.STRUCT:
12758 
          self.success = Banner()
12759 
          self.success.read(iprot)
12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      else:
12763 
        iprot.skip(ftype)
12764 
      iprot.readFieldEnd()
12765 
    iprot.readStructEnd()
12766 
 
12767 
  def write(self, oprot):
12768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12770 
      return
12771 
    oprot.writeStructBegin('getBannerDetails_result')
12772 
    if self.success is not None:
12773 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12774 
      self.success.write(oprot)
12775 
      oprot.writeFieldEnd()
12776 
    oprot.writeFieldStop()
12777 
    oprot.writeStructEnd()
12778 
 
12779 
  def validate(self):
12780 
    return
12781 
 
12782 
 
12783 
  def __repr__(self):
12784 
    L = ['%s=%r' % (key, value)
12785 
      for key, value in self.__dict__.iteritems()]
12786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12787 
 
12788 
  def __eq__(self, other):
12789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12790 
 
12791 
  def __ne__(self, other):
12792 
    return not (self == other)
12793 
 
12794 
class getActiveBanners_args:
12795 
 
12796 
  thrift_spec = (
12797 
  )
12798 
 
12799 
  def read(self, iprot):
12800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12802 
      return
12803 
    iprot.readStructBegin()
12804 
    while True:
12805 
      (fname, ftype, fid) = iprot.readFieldBegin()
12806 
      if ftype == TType.STOP:
12807 
        break
12808 
      else:
12809 
        iprot.skip(ftype)
12810 
      iprot.readFieldEnd()
12811 
    iprot.readStructEnd()
12812 
 
12813 
  def write(self, oprot):
12814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12816 
      return
12817 
    oprot.writeStructBegin('getActiveBanners_args')
12818 
    oprot.writeFieldStop()
12819 
    oprot.writeStructEnd()
12820 
 
12821 
  def validate(self):
12822 
    return
12823 
 
12824 
 
12825 
  def __repr__(self):
12826 
    L = ['%s=%r' % (key, value)
12827 
      for key, value in self.__dict__.iteritems()]
12828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12829 
 
12830 
  def __eq__(self, other):
12831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12832 
 
12833 
  def __ne__(self, other):
12834 
    return not (self == other)
12835 
 
12836 
class getActiveBanners_result:
12837 
  """
12838 
  Attributes:
12839 
   - success
12840 
  """
12841 
 
12842 
  thrift_spec = (
8579 kshitij.so 12843 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12844 
  )
12845 
 
12846 
  def __init__(self, success=None,):
12847 
    self.success = success
12848 
 
12849 
  def read(self, iprot):
12850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12852 
      return
12853 
    iprot.readStructBegin()
12854 
    while True:
12855 
      (fname, ftype, fid) = iprot.readFieldBegin()
12856 
      if ftype == TType.STOP:
12857 
        break
12858 
      if fid == 0:
8579 kshitij.so 12859 
        if ftype == TType.MAP:
12860 
          self.success = {}
8590 kshitij.so 12861 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12862 
          for _i206 in xrange(_size202):
12863 
            _key207 = iprot.readString();
12864 
            _val208 = []
12865 
            (_etype212, _size209) = iprot.readListBegin()
12866 
            for _i213 in xrange(_size209):
12867 
              _elem214 = Banner()
12868 
              _elem214.read(iprot)
12869 
              _val208.append(_elem214)
8579 kshitij.so 12870 
            iprot.readListEnd()
8590 kshitij.so 12871 
            self.success[_key207] = _val208
8579 kshitij.so 12872 
          iprot.readMapEnd()
6850 kshitij.so 12873 
        else:
12874 
          iprot.skip(ftype)
12875 
      else:
12876 
        iprot.skip(ftype)
12877 
      iprot.readFieldEnd()
12878 
    iprot.readStructEnd()
12879 
 
12880 
  def write(self, oprot):
12881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12883 
      return
12884 
    oprot.writeStructBegin('getActiveBanners_result')
12885 
    if self.success is not None:
8579 kshitij.so 12886 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12887 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12888 
      for kiter215,viter216 in self.success.items():
12889 
        oprot.writeString(kiter215)
12890 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12891 
        for iter217 in viter216:
12892 
          iter217.write(oprot)
8579 kshitij.so 12893 
        oprot.writeListEnd()
12894 
      oprot.writeMapEnd()
6850 kshitij.so 12895 
      oprot.writeFieldEnd()
12896 
    oprot.writeFieldStop()
12897 
    oprot.writeStructEnd()
12898 
 
12899 
  def validate(self):
12900 
    return
12901 
 
12902 
 
12903 
  def __repr__(self):
12904 
    L = ['%s=%r' % (key, value)
12905 
      for key, value in self.__dict__.iteritems()]
12906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12907 
 
12908 
  def __eq__(self, other):
12909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12910 
 
12911 
  def __ne__(self, other):
12912 
    return not (self == other)
12913 
 
6849 kshitij.so 12914 
class addBannerMap_args:
12915 
  """
12916 
  Attributes:
8579 kshitij.so 12917 
   - bannerMaps
6849 kshitij.so 12918 
  """
12919 
 
12920 
  thrift_spec = (
12921 
    None, # 0
8579 kshitij.so 12922 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12923 
  )
12924 
 
8579 kshitij.so 12925 
  def __init__(self, bannerMaps=None,):
12926 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12927 
 
12928 
  def read(self, iprot):
12929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12931 
      return
12932 
    iprot.readStructBegin()
12933 
    while True:
12934 
      (fname, ftype, fid) = iprot.readFieldBegin()
12935 
      if ftype == TType.STOP:
12936 
        break
12937 
      if fid == 1:
8579 kshitij.so 12938 
        if ftype == TType.LIST:
12939 
          self.bannerMaps = []
8590 kshitij.so 12940 
          (_etype221, _size218) = iprot.readListBegin()
12941 
          for _i222 in xrange(_size218):
12942 
            _elem223 = BannerMap()
12943 
            _elem223.read(iprot)
12944 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12945 
          iprot.readListEnd()
6849 kshitij.so 12946 
        else:
12947 
          iprot.skip(ftype)
8579 kshitij.so 12948 
      else:
12949 
        iprot.skip(ftype)
12950 
      iprot.readFieldEnd()
12951 
    iprot.readStructEnd()
12952 
 
12953 
  def write(self, oprot):
12954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12956 
      return
12957 
    oprot.writeStructBegin('addBannerMap_args')
12958 
    if self.bannerMaps is not None:
12959 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12960 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12961 
      for iter224 in self.bannerMaps:
12962 
        iter224.write(oprot)
8579 kshitij.so 12963 
      oprot.writeListEnd()
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 addBannerMap_result:
12984 
  """
12985 
  Attributes:
12986 
   - success
12987 
  """
12988 
 
12989 
  thrift_spec = (
12990 
    (0, TType.BOOL, 'success', None, None, ), # 0
12991 
  )
12992 
 
12993 
  def __init__(self, success=None,):
12994 
    self.success = success
12995 
 
12996 
  def read(self, iprot):
12997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12999 
      return
13000 
    iprot.readStructBegin()
13001 
    while True:
13002 
      (fname, ftype, fid) = iprot.readFieldBegin()
13003 
      if ftype == TType.STOP:
13004 
        break
13005 
      if fid == 0:
13006 
        if ftype == TType.BOOL:
13007 
          self.success = iprot.readBool();
6849 kshitij.so 13008 
        else:
13009 
          iprot.skip(ftype)
8579 kshitij.so 13010 
      else:
13011 
        iprot.skip(ftype)
13012 
      iprot.readFieldEnd()
13013 
    iprot.readStructEnd()
13014 
 
13015 
  def write(self, oprot):
13016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13018 
      return
13019 
    oprot.writeStructBegin('addBannerMap_result')
13020 
    if self.success is not None:
13021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13022 
      oprot.writeBool(self.success)
13023 
      oprot.writeFieldEnd()
13024 
    oprot.writeFieldStop()
13025 
    oprot.writeStructEnd()
13026 
 
13027 
  def validate(self):
13028 
    return
13029 
 
13030 
 
13031 
  def __repr__(self):
13032 
    L = ['%s=%r' % (key, value)
13033 
      for key, value in self.__dict__.iteritems()]
13034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13035 
 
13036 
  def __eq__(self, other):
13037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13038 
 
13039 
  def __ne__(self, other):
13040 
    return not (self == other)
13041 
 
13042 
class updateBannerMap_args:
13043 
  """
13044 
  Attributes:
13045 
   - bannerMap
13046 
  """
13047 
 
13048 
  thrift_spec = (
13049 
    None, # 0
13050 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13051 
  )
13052 
 
13053 
  def __init__(self, bannerMap=None,):
13054 
    self.bannerMap = bannerMap
13055 
 
13056 
  def read(self, iprot):
13057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13059 
      return
13060 
    iprot.readStructBegin()
13061 
    while True:
13062 
      (fname, ftype, fid) = iprot.readFieldBegin()
13063 
      if ftype == TType.STOP:
13064 
        break
13065 
      if fid == 1:
13066 
        if ftype == TType.STRUCT:
13067 
          self.bannerMap = BannerMap()
13068 
          self.bannerMap.read(iprot)
6849 kshitij.so 13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      else:
13072 
        iprot.skip(ftype)
13073 
      iprot.readFieldEnd()
13074 
    iprot.readStructEnd()
13075 
 
13076 
  def write(self, oprot):
13077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13079 
      return
8579 kshitij.so 13080 
    oprot.writeStructBegin('updateBannerMap_args')
13081 
    if self.bannerMap is not None:
13082 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13083 
      self.bannerMap.write(oprot)
6849 kshitij.so 13084 
      oprot.writeFieldEnd()
13085 
    oprot.writeFieldStop()
13086 
    oprot.writeStructEnd()
13087 
 
13088 
  def validate(self):
13089 
    return
13090 
 
13091 
 
13092 
  def __repr__(self):
13093 
    L = ['%s=%r' % (key, value)
13094 
      for key, value in self.__dict__.iteritems()]
13095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13096 
 
13097 
  def __eq__(self, other):
13098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13099 
 
13100 
  def __ne__(self, other):
13101 
    return not (self == other)
13102 
 
8579 kshitij.so 13103 
class updateBannerMap_result:
6849 kshitij.so 13104 
  """
13105 
  Attributes:
13106 
   - success
13107 
  """
13108 
 
13109 
  thrift_spec = (
13110 
    (0, TType.BOOL, 'success', None, None, ), # 0
13111 
  )
13112 
 
13113 
  def __init__(self, success=None,):
13114 
    self.success = success
13115 
 
13116 
  def read(self, iprot):
13117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13119 
      return
13120 
    iprot.readStructBegin()
13121 
    while True:
13122 
      (fname, ftype, fid) = iprot.readFieldBegin()
13123 
      if ftype == TType.STOP:
13124 
        break
13125 
      if fid == 0:
13126 
        if ftype == TType.BOOL:
13127 
          self.success = iprot.readBool();
13128 
        else:
13129 
          iprot.skip(ftype)
13130 
      else:
13131 
        iprot.skip(ftype)
13132 
      iprot.readFieldEnd()
13133 
    iprot.readStructEnd()
13134 
 
13135 
  def write(self, oprot):
13136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13138 
      return
8579 kshitij.so 13139 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13140 
    if self.success is not None:
13141 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13142 
      oprot.writeBool(self.success)
13143 
      oprot.writeFieldEnd()
13144 
    oprot.writeFieldStop()
13145 
    oprot.writeStructEnd()
13146 
 
13147 
  def validate(self):
13148 
    return
13149 
 
13150 
 
13151 
  def __repr__(self):
13152 
    L = ['%s=%r' % (key, value)
13153 
      for key, value in self.__dict__.iteritems()]
13154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13155 
 
13156 
  def __eq__(self, other):
13157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13158 
 
13159 
  def __ne__(self, other):
13160 
    return not (self == other)
13161 
 
13162 
class deleteBannerMap_args:
13163 
  """
13164 
  Attributes:
13165 
   - bannerName
13166 
  """
13167 
 
13168 
  thrift_spec = (
13169 
    None, # 0
13170 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13171 
  )
13172 
 
13173 
  def __init__(self, bannerName=None,):
13174 
    self.bannerName = bannerName
13175 
 
13176 
  def read(self, iprot):
13177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13179 
      return
13180 
    iprot.readStructBegin()
13181 
    while True:
13182 
      (fname, ftype, fid) = iprot.readFieldBegin()
13183 
      if ftype == TType.STOP:
13184 
        break
13185 
      if fid == 1:
13186 
        if ftype == TType.STRING:
13187 
          self.bannerName = iprot.readString();
13188 
        else:
13189 
          iprot.skip(ftype)
13190 
      else:
13191 
        iprot.skip(ftype)
13192 
      iprot.readFieldEnd()
13193 
    iprot.readStructEnd()
13194 
 
13195 
  def write(self, oprot):
13196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13198 
      return
13199 
    oprot.writeStructBegin('deleteBannerMap_args')
13200 
    if self.bannerName is not None:
13201 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13202 
      oprot.writeString(self.bannerName)
13203 
      oprot.writeFieldEnd()
13204 
    oprot.writeFieldStop()
13205 
    oprot.writeStructEnd()
13206 
 
13207 
  def validate(self):
13208 
    return
13209 
 
13210 
 
13211 
  def __repr__(self):
13212 
    L = ['%s=%r' % (key, value)
13213 
      for key, value in self.__dict__.iteritems()]
13214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13215 
 
13216 
  def __eq__(self, other):
13217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13218 
 
13219 
  def __ne__(self, other):
13220 
    return not (self == other)
13221 
 
13222 
class deleteBannerMap_result:
13223 
  """
13224 
  Attributes:
13225 
   - success
13226 
  """
13227 
 
13228 
  thrift_spec = (
13229 
    (0, TType.BOOL, 'success', None, None, ), # 0
13230 
  )
13231 
 
13232 
  def __init__(self, success=None,):
13233 
    self.success = success
13234 
 
13235 
  def read(self, iprot):
13236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13238 
      return
13239 
    iprot.readStructBegin()
13240 
    while True:
13241 
      (fname, ftype, fid) = iprot.readFieldBegin()
13242 
      if ftype == TType.STOP:
13243 
        break
13244 
      if fid == 0:
13245 
        if ftype == TType.BOOL:
13246 
          self.success = iprot.readBool();
13247 
        else:
13248 
          iprot.skip(ftype)
13249 
      else:
13250 
        iprot.skip(ftype)
13251 
      iprot.readFieldEnd()
13252 
    iprot.readStructEnd()
13253 
 
13254 
  def write(self, oprot):
13255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13257 
      return
13258 
    oprot.writeStructBegin('deleteBannerMap_result')
13259 
    if self.success is not None:
13260 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13261 
      oprot.writeBool(self.success)
13262 
      oprot.writeFieldEnd()
13263 
    oprot.writeFieldStop()
13264 
    oprot.writeStructEnd()
13265 
 
13266 
  def validate(self):
13267 
    return
13268 
 
13269 
 
13270 
  def __repr__(self):
13271 
    L = ['%s=%r' % (key, value)
13272 
      for key, value in self.__dict__.iteritems()]
13273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13274 
 
13275 
  def __eq__(self, other):
13276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13277 
 
13278 
  def __ne__(self, other):
13279 
    return not (self == other)
13280 
 
13281 
class getBannerMapDetails_args:
13282 
  """
13283 
  Attributes:
13284 
   - bannerName
9155 kshitij.so 13285 
   - bannerType
6849 kshitij.so 13286 
  """
13287 
 
13288 
  thrift_spec = (
13289 
    None, # 0
13290 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13291 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13292 
  )
13293 
 
9155 kshitij.so 13294 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13295 
    self.bannerName = bannerName
9155 kshitij.so 13296 
    self.bannerType = bannerType
6849 kshitij.so 13297 
 
13298 
  def read(self, iprot):
13299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13301 
      return
13302 
    iprot.readStructBegin()
13303 
    while True:
13304 
      (fname, ftype, fid) = iprot.readFieldBegin()
13305 
      if ftype == TType.STOP:
13306 
        break
13307 
      if fid == 1:
13308 
        if ftype == TType.STRING:
13309 
          self.bannerName = iprot.readString();
13310 
        else:
13311 
          iprot.skip(ftype)
9155 kshitij.so 13312 
      elif fid == 2:
13313 
        if ftype == TType.I32:
13314 
          self.bannerType = iprot.readI32();
13315 
        else:
13316 
          iprot.skip(ftype)
6849 kshitij.so 13317 
      else:
13318 
        iprot.skip(ftype)
13319 
      iprot.readFieldEnd()
13320 
    iprot.readStructEnd()
13321 
 
13322 
  def write(self, oprot):
13323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13325 
      return
13326 
    oprot.writeStructBegin('getBannerMapDetails_args')
13327 
    if self.bannerName is not None:
13328 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13329 
      oprot.writeString(self.bannerName)
13330 
      oprot.writeFieldEnd()
9155 kshitij.so 13331 
    if self.bannerType is not None:
13332 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13333 
      oprot.writeI32(self.bannerType)
13334 
      oprot.writeFieldEnd()
6849 kshitij.so 13335 
    oprot.writeFieldStop()
13336 
    oprot.writeStructEnd()
13337 
 
13338 
  def validate(self):
13339 
    return
13340 
 
13341 
 
13342 
  def __repr__(self):
13343 
    L = ['%s=%r' % (key, value)
13344 
      for key, value in self.__dict__.iteritems()]
13345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13346 
 
13347 
  def __eq__(self, other):
13348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13349 
 
13350 
  def __ne__(self, other):
13351 
    return not (self == other)
13352 
 
13353 
class getBannerMapDetails_result:
13354 
  """
13355 
  Attributes:
13356 
   - success
13357 
  """
13358 
 
13359 
  thrift_spec = (
13360 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13361 
  )
13362 
 
13363 
  def __init__(self, success=None,):
13364 
    self.success = success
13365 
 
13366 
  def read(self, iprot):
13367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13369 
      return
13370 
    iprot.readStructBegin()
13371 
    while True:
13372 
      (fname, ftype, fid) = iprot.readFieldBegin()
13373 
      if ftype == TType.STOP:
13374 
        break
13375 
      if fid == 0:
13376 
        if ftype == TType.LIST:
13377 
          self.success = []
8590 kshitij.so 13378 
          (_etype228, _size225) = iprot.readListBegin()
13379 
          for _i229 in xrange(_size225):
13380 
            _elem230 = BannerMap()
13381 
            _elem230.read(iprot)
13382 
            self.success.append(_elem230)
6849 kshitij.so 13383 
          iprot.readListEnd()
13384 
        else:
13385 
          iprot.skip(ftype)
13386 
      else:
13387 
        iprot.skip(ftype)
13388 
      iprot.readFieldEnd()
13389 
    iprot.readStructEnd()
13390 
 
13391 
  def write(self, oprot):
13392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13394 
      return
13395 
    oprot.writeStructBegin('getBannerMapDetails_result')
13396 
    if self.success is not None:
13397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13399 
      for iter231 in self.success:
13400 
        iter231.write(oprot)
6849 kshitij.so 13401 
      oprot.writeListEnd()
13402 
      oprot.writeFieldEnd()
13403 
    oprot.writeFieldStop()
13404 
    oprot.writeStructEnd()
13405 
 
13406 
  def validate(self):
13407 
    return
13408 
 
13409 
 
13410 
  def __repr__(self):
13411 
    L = ['%s=%r' % (key, value)
13412 
      for key, value in self.__dict__.iteritems()]
13413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13414 
 
13415 
  def __eq__(self, other):
13416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13417 
 
13418 
  def __ne__(self, other):
13419 
    return not (self == other)
13420 
 
8579 kshitij.so 13421 
class addBannerUri_args:
13422 
  """
13423 
  Attributes:
13424 
   - bannerUriMappings
13425 
  """
13426 
 
13427 
  thrift_spec = (
13428 
    None, # 0
13429 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13430 
  )
13431 
 
13432 
  def __init__(self, bannerUriMappings=None,):
13433 
    self.bannerUriMappings = bannerUriMappings
13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 1:
13445 
        if ftype == TType.LIST:
13446 
          self.bannerUriMappings = []
8590 kshitij.so 13447 
          (_etype235, _size232) = iprot.readListBegin()
13448 
          for _i236 in xrange(_size232):
13449 
            _elem237 = BannerUriMapping()
13450 
            _elem237.read(iprot)
13451 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13452 
          iprot.readListEnd()
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      else:
13456 
        iprot.skip(ftype)
13457 
      iprot.readFieldEnd()
13458 
    iprot.readStructEnd()
13459 
 
13460 
  def write(self, oprot):
13461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13463 
      return
13464 
    oprot.writeStructBegin('addBannerUri_args')
13465 
    if self.bannerUriMappings is not None:
13466 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13467 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13468 
      for iter238 in self.bannerUriMappings:
13469 
        iter238.write(oprot)
8579 kshitij.so 13470 
      oprot.writeListEnd()
13471 
      oprot.writeFieldEnd()
13472 
    oprot.writeFieldStop()
13473 
    oprot.writeStructEnd()
13474 
 
13475 
  def validate(self):
13476 
    return
13477 
 
13478 
 
13479 
  def __repr__(self):
13480 
    L = ['%s=%r' % (key, value)
13481 
      for key, value in self.__dict__.iteritems()]
13482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13483 
 
13484 
  def __eq__(self, other):
13485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13486 
 
13487 
  def __ne__(self, other):
13488 
    return not (self == other)
13489 
 
13490 
class addBannerUri_result:
13491 
 
13492 
  thrift_spec = (
13493 
  )
13494 
 
13495 
  def read(self, iprot):
13496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13498 
      return
13499 
    iprot.readStructBegin()
13500 
    while True:
13501 
      (fname, ftype, fid) = iprot.readFieldBegin()
13502 
      if ftype == TType.STOP:
13503 
        break
13504 
      else:
13505 
        iprot.skip(ftype)
13506 
      iprot.readFieldEnd()
13507 
    iprot.readStructEnd()
13508 
 
13509 
  def write(self, oprot):
13510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13512 
      return
13513 
    oprot.writeStructBegin('addBannerUri_result')
13514 
    oprot.writeFieldStop()
13515 
    oprot.writeStructEnd()
13516 
 
13517 
  def validate(self):
13518 
    return
13519 
 
13520 
 
13521 
  def __repr__(self):
13522 
    L = ['%s=%r' % (key, value)
13523 
      for key, value in self.__dict__.iteritems()]
13524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13525 
 
13526 
  def __eq__(self, other):
13527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13528 
 
13529 
  def __ne__(self, other):
13530 
    return not (self == other)
13531 
 
13532 
class getUriMapping_args:
13533 
  """
13534 
  Attributes:
13535 
   - bannerName
9155 kshitij.so 13536 
   - bannerType
8579 kshitij.so 13537 
  """
13538 
 
13539 
  thrift_spec = (
13540 
    None, # 0
13541 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13542 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 13543 
  )
13544 
 
9155 kshitij.so 13545 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 13546 
    self.bannerName = bannerName
9155 kshitij.so 13547 
    self.bannerType = bannerType
8579 kshitij.so 13548 
 
13549 
  def read(self, iprot):
13550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13552 
      return
13553 
    iprot.readStructBegin()
13554 
    while True:
13555 
      (fname, ftype, fid) = iprot.readFieldBegin()
13556 
      if ftype == TType.STOP:
13557 
        break
13558 
      if fid == 1:
13559 
        if ftype == TType.STRING:
13560 
          self.bannerName = iprot.readString();
13561 
        else:
13562 
          iprot.skip(ftype)
9155 kshitij.so 13563 
      elif fid == 2:
13564 
        if ftype == TType.I32:
13565 
          self.bannerType = iprot.readI32();
13566 
        else:
13567 
          iprot.skip(ftype)
8579 kshitij.so 13568 
      else:
13569 
        iprot.skip(ftype)
13570 
      iprot.readFieldEnd()
13571 
    iprot.readStructEnd()
13572 
 
13573 
  def write(self, oprot):
13574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13576 
      return
13577 
    oprot.writeStructBegin('getUriMapping_args')
13578 
    if self.bannerName is not None:
13579 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13580 
      oprot.writeString(self.bannerName)
13581 
      oprot.writeFieldEnd()
9155 kshitij.so 13582 
    if self.bannerType is not None:
13583 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13584 
      oprot.writeI32(self.bannerType)
13585 
      oprot.writeFieldEnd()
8579 kshitij.so 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 getUriMapping_result:
13605 
  """
13606 
  Attributes:
13607 
   - success
13608 
  """
13609 
 
13610 
  thrift_spec = (
13611 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13612 
  )
13613 
 
13614 
  def __init__(self, success=None,):
13615 
    self.success = success
13616 
 
13617 
  def read(self, iprot):
13618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13620 
      return
13621 
    iprot.readStructBegin()
13622 
    while True:
13623 
      (fname, ftype, fid) = iprot.readFieldBegin()
13624 
      if ftype == TType.STOP:
13625 
        break
13626 
      if fid == 0:
13627 
        if ftype == TType.LIST:
13628 
          self.success = []
8590 kshitij.so 13629 
          (_etype242, _size239) = iprot.readListBegin()
13630 
          for _i243 in xrange(_size239):
13631 
            _elem244 = BannerUriMapping()
13632 
            _elem244.read(iprot)
13633 
            self.success.append(_elem244)
8579 kshitij.so 13634 
          iprot.readListEnd()
13635 
        else:
13636 
          iprot.skip(ftype)
13637 
      else:
13638 
        iprot.skip(ftype)
13639 
      iprot.readFieldEnd()
13640 
    iprot.readStructEnd()
13641 
 
13642 
  def write(self, oprot):
13643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13645 
      return
13646 
    oprot.writeStructBegin('getUriMapping_result')
13647 
    if self.success is not None:
13648 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13649 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13650 
      for iter245 in self.success:
13651 
        iter245.write(oprot)
8579 kshitij.so 13652 
      oprot.writeListEnd()
13653 
      oprot.writeFieldEnd()
13654 
    oprot.writeFieldStop()
13655 
    oprot.writeStructEnd()
13656 
 
13657 
  def validate(self):
13658 
    return
13659 
 
13660 
 
13661 
  def __repr__(self):
13662 
    L = ['%s=%r' % (key, value)
13663 
      for key, value in self.__dict__.iteritems()]
13664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13665 
 
13666 
  def __eq__(self, other):
13667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13668 
 
13669 
  def __ne__(self, other):
13670 
    return not (self == other)
13671 
 
13672 
class addCampaign_args:
13673 
  """
13674 
  Attributes:
13675 
   - campaign
13676 
  """
13677 
 
13678 
  thrift_spec = (
13679 
    None, # 0
13680 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13681 
  )
13682 
 
13683 
  def __init__(self, campaign=None,):
13684 
    self.campaign = campaign
13685 
 
13686 
  def read(self, iprot):
13687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13689 
      return
13690 
    iprot.readStructBegin()
13691 
    while True:
13692 
      (fname, ftype, fid) = iprot.readFieldBegin()
13693 
      if ftype == TType.STOP:
13694 
        break
13695 
      if fid == 1:
13696 
        if ftype == TType.STRUCT:
13697 
          self.campaign = Campaign()
13698 
          self.campaign.read(iprot)
13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      else:
13702 
        iprot.skip(ftype)
13703 
      iprot.readFieldEnd()
13704 
    iprot.readStructEnd()
13705 
 
13706 
  def write(self, oprot):
13707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13709 
      return
13710 
    oprot.writeStructBegin('addCampaign_args')
13711 
    if self.campaign is not None:
13712 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13713 
      self.campaign.write(oprot)
13714 
      oprot.writeFieldEnd()
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
13732 
 
13733 
class addCampaign_result:
13734 
 
13735 
  thrift_spec = (
13736 
  )
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 
      else:
13748 
        iprot.skip(ftype)
13749 
      iprot.readFieldEnd()
13750 
    iprot.readStructEnd()
13751 
 
13752 
  def write(self, oprot):
13753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13755 
      return
13756 
    oprot.writeStructBegin('addCampaign_result')
13757 
    oprot.writeFieldStop()
13758 
    oprot.writeStructEnd()
13759 
 
13760 
  def validate(self):
13761 
    return
13762 
 
13763 
 
13764 
  def __repr__(self):
13765 
    L = ['%s=%r' % (key, value)
13766 
      for key, value in self.__dict__.iteritems()]
13767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13768 
 
13769 
  def __eq__(self, other):
13770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13771 
 
13772 
  def __ne__(self, other):
13773 
    return not (self == other)
13774 
 
13775 
class getCampaigns_args:
13776 
  """
13777 
  Attributes:
13778 
   - campaignName
13779 
  """
13780 
 
13781 
  thrift_spec = (
13782 
    None, # 0
13783 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13784 
  )
13785 
 
13786 
  def __init__(self, campaignName=None,):
13787 
    self.campaignName = campaignName
13788 
 
13789 
  def read(self, iprot):
13790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13792 
      return
13793 
    iprot.readStructBegin()
13794 
    while True:
13795 
      (fname, ftype, fid) = iprot.readFieldBegin()
13796 
      if ftype == TType.STOP:
13797 
        break
13798 
      if fid == 1:
13799 
        if ftype == TType.STRING:
13800 
          self.campaignName = iprot.readString();
13801 
        else:
13802 
          iprot.skip(ftype)
13803 
      else:
13804 
        iprot.skip(ftype)
13805 
      iprot.readFieldEnd()
13806 
    iprot.readStructEnd()
13807 
 
13808 
  def write(self, oprot):
13809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13811 
      return
13812 
    oprot.writeStructBegin('getCampaigns_args')
13813 
    if self.campaignName is not None:
13814 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13815 
      oprot.writeString(self.campaignName)
13816 
      oprot.writeFieldEnd()
13817 
    oprot.writeFieldStop()
13818 
    oprot.writeStructEnd()
13819 
 
13820 
  def validate(self):
13821 
    return
13822 
 
13823 
 
13824 
  def __repr__(self):
13825 
    L = ['%s=%r' % (key, value)
13826 
      for key, value in self.__dict__.iteritems()]
13827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13828 
 
13829 
  def __eq__(self, other):
13830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13831 
 
13832 
  def __ne__(self, other):
13833 
    return not (self == other)
13834 
 
13835 
class getCampaigns_result:
13836 
  """
13837 
  Attributes:
13838 
   - success
13839 
  """
13840 
 
13841 
  thrift_spec = (
13842 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13843 
  )
13844 
 
13845 
  def __init__(self, success=None,):
13846 
    self.success = success
13847 
 
13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
13857 
      if fid == 0:
13858 
        if ftype == TType.LIST:
13859 
          self.success = []
8590 kshitij.so 13860 
          (_etype249, _size246) = iprot.readListBegin()
13861 
          for _i250 in xrange(_size246):
13862 
            _elem251 = Campaign()
13863 
            _elem251.read(iprot)
13864 
            self.success.append(_elem251)
8579 kshitij.so 13865 
          iprot.readListEnd()
13866 
        else:
13867 
          iprot.skip(ftype)
13868 
      else:
13869 
        iprot.skip(ftype)
13870 
      iprot.readFieldEnd()
13871 
    iprot.readStructEnd()
13872 
 
13873 
  def write(self, oprot):
13874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13876 
      return
13877 
    oprot.writeStructBegin('getCampaigns_result')
13878 
    if self.success is not None:
13879 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13880 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13881 
      for iter252 in self.success:
13882 
        iter252.write(oprot)
8579 kshitij.so 13883 
      oprot.writeListEnd()
13884 
      oprot.writeFieldEnd()
13885 
    oprot.writeFieldStop()
13886 
    oprot.writeStructEnd()
13887 
 
13888 
  def validate(self):
13889 
    return
13890 
 
13891 
 
13892 
  def __repr__(self):
13893 
    L = ['%s=%r' % (key, value)
13894 
      for key, value in self.__dict__.iteritems()]
13895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13896 
 
13897 
  def __eq__(self, other):
13898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13899 
 
13900 
  def __ne__(self, other):
13901 
    return not (self == other)
13902 
 
13903 
class deleteCampaign_args:
13904 
  """
13905 
  Attributes:
13906 
   - campaignId
13907 
  """
13908 
 
13909 
  thrift_spec = (
13910 
    None, # 0
13911 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13912 
  )
13913 
 
13914 
  def __init__(self, campaignId=None,):
13915 
    self.campaignId = campaignId
13916 
 
13917 
  def read(self, iprot):
13918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13920 
      return
13921 
    iprot.readStructBegin()
13922 
    while True:
13923 
      (fname, ftype, fid) = iprot.readFieldBegin()
13924 
      if ftype == TType.STOP:
13925 
        break
13926 
      if fid == 1:
13927 
        if ftype == TType.I64:
13928 
          self.campaignId = iprot.readI64();
13929 
        else:
13930 
          iprot.skip(ftype)
13931 
      else:
13932 
        iprot.skip(ftype)
13933 
      iprot.readFieldEnd()
13934 
    iprot.readStructEnd()
13935 
 
13936 
  def write(self, oprot):
13937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13939 
      return
13940 
    oprot.writeStructBegin('deleteCampaign_args')
13941 
    if self.campaignId is not None:
13942 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13943 
      oprot.writeI64(self.campaignId)
13944 
      oprot.writeFieldEnd()
13945 
    oprot.writeFieldStop()
13946 
    oprot.writeStructEnd()
13947 
 
13948 
  def validate(self):
13949 
    return
13950 
 
13951 
 
13952 
  def __repr__(self):
13953 
    L = ['%s=%r' % (key, value)
13954 
      for key, value in self.__dict__.iteritems()]
13955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13956 
 
13957 
  def __eq__(self, other):
13958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13959 
 
13960 
  def __ne__(self, other):
13961 
    return not (self == other)
13962 
 
13963 
class deleteCampaign_result:
13964 
 
13965 
  thrift_spec = (
13966 
  )
13967 
 
13968 
  def read(self, iprot):
13969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13971 
      return
13972 
    iprot.readStructBegin()
13973 
    while True:
13974 
      (fname, ftype, fid) = iprot.readFieldBegin()
13975 
      if ftype == TType.STOP:
13976 
        break
13977 
      else:
13978 
        iprot.skip(ftype)
13979 
      iprot.readFieldEnd()
13980 
    iprot.readStructEnd()
13981 
 
13982 
  def write(self, oprot):
13983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13985 
      return
13986 
    oprot.writeStructBegin('deleteCampaign_result')
13987 
    oprot.writeFieldStop()
13988 
    oprot.writeStructEnd()
13989 
 
13990 
  def validate(self):
13991 
    return
13992 
 
13993 
 
13994 
  def __repr__(self):
13995 
    L = ['%s=%r' % (key, value)
13996 
      for key, value in self.__dict__.iteritems()]
13997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13998 
 
13999 
  def __eq__(self, other):
14000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14001 
 
14002 
  def __ne__(self, other):
14003 
    return not (self == other)
14004 
 
14005 
class getAllCampaigns_args:
14006 
 
14007 
  thrift_spec = (
14008 
  )
14009 
 
14010 
  def read(self, iprot):
14011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14013 
      return
14014 
    iprot.readStructBegin()
14015 
    while True:
14016 
      (fname, ftype, fid) = iprot.readFieldBegin()
14017 
      if ftype == TType.STOP:
14018 
        break
14019 
      else:
14020 
        iprot.skip(ftype)
14021 
      iprot.readFieldEnd()
14022 
    iprot.readStructEnd()
14023 
 
14024 
  def write(self, oprot):
14025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14027 
      return
14028 
    oprot.writeStructBegin('getAllCampaigns_args')
14029 
    oprot.writeFieldStop()
14030 
    oprot.writeStructEnd()
14031 
 
14032 
  def validate(self):
14033 
    return
14034 
 
14035 
 
14036 
  def __repr__(self):
14037 
    L = ['%s=%r' % (key, value)
14038 
      for key, value in self.__dict__.iteritems()]
14039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14040 
 
14041 
  def __eq__(self, other):
14042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14043 
 
14044 
  def __ne__(self, other):
14045 
    return not (self == other)
14046 
 
14047 
class getAllCampaigns_result:
14048 
  """
14049 
  Attributes:
14050 
   - success
14051 
  """
14052 
 
14053 
  thrift_spec = (
14054 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14055 
  )
14056 
 
14057 
  def __init__(self, success=None,):
14058 
    self.success = success
14059 
 
14060 
  def read(self, iprot):
14061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14063 
      return
14064 
    iprot.readStructBegin()
14065 
    while True:
14066 
      (fname, ftype, fid) = iprot.readFieldBegin()
14067 
      if ftype == TType.STOP:
14068 
        break
14069 
      if fid == 0:
14070 
        if ftype == TType.LIST:
14071 
          self.success = []
8590 kshitij.so 14072 
          (_etype256, _size253) = iprot.readListBegin()
14073 
          for _i257 in xrange(_size253):
14074 
            _elem258 = iprot.readString();
14075 
            self.success.append(_elem258)
8579 kshitij.so 14076 
          iprot.readListEnd()
14077 
        else:
14078 
          iprot.skip(ftype)
14079 
      else:
14080 
        iprot.skip(ftype)
14081 
      iprot.readFieldEnd()
14082 
    iprot.readStructEnd()
14083 
 
14084 
  def write(self, oprot):
14085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14087 
      return
14088 
    oprot.writeStructBegin('getAllCampaigns_result')
14089 
    if self.success is not None:
14090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14091 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14092 
      for iter259 in self.success:
14093 
        oprot.writeString(iter259)
8579 kshitij.so 14094 
      oprot.writeListEnd()
14095 
      oprot.writeFieldEnd()
14096 
    oprot.writeFieldStop()
14097 
    oprot.writeStructEnd()
14098 
 
14099 
  def validate(self):
14100 
    return
14101 
 
14102 
 
14103 
  def __repr__(self):
14104 
    L = ['%s=%r' % (key, value)
14105 
      for key, value in self.__dict__.iteritems()]
14106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14107 
 
14108 
  def __eq__(self, other):
14109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14110 
 
14111 
  def __ne__(self, other):
14112 
    return not (self == other)
14113 
 
9155 kshitij.so 14114 
class getActiveBannersForMobileSite_args:
14115 
 
14116 
  thrift_spec = (
14117 
  )
14118 
 
14119 
  def read(self, iprot):
14120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14122 
      return
14123 
    iprot.readStructBegin()
14124 
    while True:
14125 
      (fname, ftype, fid) = iprot.readFieldBegin()
14126 
      if ftype == TType.STOP:
14127 
        break
14128 
      else:
14129 
        iprot.skip(ftype)
14130 
      iprot.readFieldEnd()
14131 
    iprot.readStructEnd()
14132 
 
14133 
  def write(self, oprot):
14134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14136 
      return
14137 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14138 
    oprot.writeFieldStop()
14139 
    oprot.writeStructEnd()
14140 
 
14141 
  def validate(self):
14142 
    return
14143 
 
14144 
 
14145 
  def __repr__(self):
14146 
    L = ['%s=%r' % (key, value)
14147 
      for key, value in self.__dict__.iteritems()]
14148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14149 
 
14150 
  def __eq__(self, other):
14151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14152 
 
14153 
  def __ne__(self, other):
14154 
    return not (self == other)
14155 
 
14156 
class getActiveBannersForMobileSite_result:
14157 
  """
14158 
  Attributes:
14159 
   - success
14160 
  """
14161 
 
14162 
  thrift_spec = (
14163 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14164 
  )
14165 
 
14166 
  def __init__(self, success=None,):
14167 
    self.success = success
14168 
 
14169 
  def read(self, iprot):
14170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14172 
      return
14173 
    iprot.readStructBegin()
14174 
    while True:
14175 
      (fname, ftype, fid) = iprot.readFieldBegin()
14176 
      if ftype == TType.STOP:
14177 
        break
14178 
      if fid == 0:
14179 
        if ftype == TType.MAP:
14180 
          self.success = {}
14181 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14182 
          for _i264 in xrange(_size260):
14183 
            _key265 = iprot.readString();
14184 
            _val266 = []
14185 
            (_etype270, _size267) = iprot.readListBegin()
14186 
            for _i271 in xrange(_size267):
14187 
              _elem272 = Banner()
14188 
              _elem272.read(iprot)
14189 
              _val266.append(_elem272)
14190 
            iprot.readListEnd()
14191 
            self.success[_key265] = _val266
14192 
          iprot.readMapEnd()
14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      else:
14196 
        iprot.skip(ftype)
14197 
      iprot.readFieldEnd()
14198 
    iprot.readStructEnd()
14199 
 
14200 
  def write(self, oprot):
14201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14203 
      return
14204 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14205 
    if self.success is not None:
14206 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14207 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14208 
      for kiter273,viter274 in self.success.items():
14209 
        oprot.writeString(kiter273)
14210 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14211 
        for iter275 in viter274:
14212 
          iter275.write(oprot)
14213 
        oprot.writeListEnd()
14214 
      oprot.writeMapEnd()
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 
 
5944 mandeep.dh 14234 
class deleteSimilarItem_args:
14235 
  """
14236 
  Attributes:
14237 
   - itemId
14238 
   - catalogItemId
14239 
  """
14240 
 
14241 
  thrift_spec = (
14242 
    None, # 0
14243 
    (1, TType.I64, 'itemId', None, None, ), # 1
14244 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14245 
  )
14246 
 
14247 
  def __init__(self, itemId=None, catalogItemId=None,):
14248 
    self.itemId = itemId
14249 
    self.catalogItemId = catalogItemId
14250 
 
14251 
  def read(self, iprot):
14252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14254 
      return
14255 
    iprot.readStructBegin()
14256 
    while True:
14257 
      (fname, ftype, fid) = iprot.readFieldBegin()
14258 
      if ftype == TType.STOP:
14259 
        break
14260 
      if fid == 1:
14261 
        if ftype == TType.I64:
14262 
          self.itemId = iprot.readI64();
14263 
        else:
14264 
          iprot.skip(ftype)
14265 
      elif fid == 2:
14266 
        if ftype == TType.I64:
14267 
          self.catalogItemId = iprot.readI64();
14268 
        else:
14269 
          iprot.skip(ftype)
14270 
      else:
14271 
        iprot.skip(ftype)
14272 
      iprot.readFieldEnd()
14273 
    iprot.readStructEnd()
14274 
 
14275 
  def write(self, oprot):
14276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14278 
      return
14279 
    oprot.writeStructBegin('deleteSimilarItem_args')
14280 
    if self.itemId is not None:
14281 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14282 
      oprot.writeI64(self.itemId)
14283 
      oprot.writeFieldEnd()
14284 
    if self.catalogItemId is not None:
14285 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14286 
      oprot.writeI64(self.catalogItemId)
14287 
      oprot.writeFieldEnd()
14288 
    oprot.writeFieldStop()
14289 
    oprot.writeStructEnd()
14290 
 
14291 
  def validate(self):
14292 
    return
14293 
 
14294 
 
14295 
  def __repr__(self):
14296 
    L = ['%s=%r' % (key, value)
14297 
      for key, value in self.__dict__.iteritems()]
14298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14299 
 
14300 
  def __eq__(self, other):
14301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14302 
 
14303 
  def __ne__(self, other):
14304 
    return not (self == other)
14305 
 
14306 
class deleteSimilarItem_result:
14307 
  """
14308 
  Attributes:
14309 
   - success
14310 
   - cex
14311 
  """
14312 
 
14313 
  thrift_spec = (
14314 
    (0, TType.BOOL, 'success', None, None, ), # 0
14315 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14316 
  )
14317 
 
14318 
  def __init__(self, success=None, cex=None,):
14319 
    self.success = success
14320 
    self.cex = cex
14321 
 
14322 
  def read(self, iprot):
14323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14325 
      return
14326 
    iprot.readStructBegin()
14327 
    while True:
14328 
      (fname, ftype, fid) = iprot.readFieldBegin()
14329 
      if ftype == TType.STOP:
14330 
        break
14331 
      if fid == 0:
14332 
        if ftype == TType.BOOL:
14333 
          self.success = iprot.readBool();
14334 
        else:
14335 
          iprot.skip(ftype)
14336 
      elif fid == 1:
14337 
        if ftype == TType.STRUCT:
14338 
          self.cex = CatalogServiceException()
14339 
          self.cex.read(iprot)
14340 
        else:
14341 
          iprot.skip(ftype)
14342 
      else:
14343 
        iprot.skip(ftype)
14344 
      iprot.readFieldEnd()
14345 
    iprot.readStructEnd()
14346 
 
14347 
  def write(self, oprot):
14348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14350 
      return
14351 
    oprot.writeStructBegin('deleteSimilarItem_result')
14352 
    if self.success is not None:
14353 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14354 
      oprot.writeBool(self.success)
14355 
      oprot.writeFieldEnd()
14356 
    if self.cex is not None:
14357 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14358 
      self.cex.write(oprot)
14359 
      oprot.writeFieldEnd()
14360 
    oprot.writeFieldStop()
14361 
    oprot.writeStructEnd()
14362 
 
14363 
  def validate(self):
14364 
    return
14365 
 
14366 
 
14367 
  def __repr__(self):
14368 
    L = ['%s=%r' % (key, value)
14369 
      for key, value in self.__dict__.iteritems()]
14370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14371 
 
14372 
  def __eq__(self, other):
14373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14374 
 
14375 
  def __ne__(self, other):
14376 
    return not (self == other)
14377 
 
14378 
class checkSimilarItem_args:
14379 
  """
14380 
  Attributes:
14381 
   - brand
14382 
   - modelNumber
14383 
   - modelName
14384 
   - color
14385 
  """
14386 
 
14387 
  thrift_spec = (
14388 
    None, # 0
14389 
    (1, TType.STRING, 'brand', None, None, ), # 1
14390 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14391 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14392 
    (4, TType.STRING, 'color', None, None, ), # 4
14393 
  )
14394 
 
14395 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14396 
    self.brand = brand
14397 
    self.modelNumber = modelNumber
14398 
    self.modelName = modelName
14399 
    self.color = color
14400 
 
14401 
  def read(self, iprot):
14402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14404 
      return
14405 
    iprot.readStructBegin()
14406 
    while True:
14407 
      (fname, ftype, fid) = iprot.readFieldBegin()
14408 
      if ftype == TType.STOP:
14409 
        break
14410 
      if fid == 1:
14411 
        if ftype == TType.STRING:
14412 
          self.brand = iprot.readString();
14413 
        else:
14414 
          iprot.skip(ftype)
14415 
      elif fid == 2:
14416 
        if ftype == TType.STRING:
14417 
          self.modelNumber = iprot.readString();
14418 
        else:
14419 
          iprot.skip(ftype)
14420 
      elif fid == 3:
14421 
        if ftype == TType.STRING:
14422 
          self.modelName = iprot.readString();
14423 
        else:
14424 
          iprot.skip(ftype)
14425 
      elif fid == 4:
14426 
        if ftype == TType.STRING:
14427 
          self.color = iprot.readString();
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('checkSimilarItem_args')
14440 
    if self.brand is not None:
14441 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14442 
      oprot.writeString(self.brand)
14443 
      oprot.writeFieldEnd()
14444 
    if self.modelNumber is not None:
14445 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14446 
      oprot.writeString(self.modelNumber)
14447 
      oprot.writeFieldEnd()
14448 
    if self.modelName is not None:
14449 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14450 
      oprot.writeString(self.modelName)
14451 
      oprot.writeFieldEnd()
14452 
    if self.color is not None:
14453 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14454 
      oprot.writeString(self.color)
14455 
      oprot.writeFieldEnd()
14456 
    oprot.writeFieldStop()
14457 
    oprot.writeStructEnd()
14458 
 
14459 
  def validate(self):
14460 
    return
14461 
 
14462 
 
14463 
  def __repr__(self):
14464 
    L = ['%s=%r' % (key, value)
14465 
      for key, value in self.__dict__.iteritems()]
14466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14467 
 
14468 
  def __eq__(self, other):
14469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14470 
 
14471 
  def __ne__(self, other):
14472 
    return not (self == other)
14473 
 
14474 
class checkSimilarItem_result:
14475 
  """
14476 
  Attributes:
14477 
   - success
14478 
  """
14479 
 
14480 
  thrift_spec = (
14481 
    (0, TType.I64, 'success', None, None, ), # 0
14482 
  )
14483 
 
14484 
  def __init__(self, success=None,):
14485 
    self.success = success
14486 
 
14487 
  def read(self, iprot):
14488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14490 
      return
14491 
    iprot.readStructBegin()
14492 
    while True:
14493 
      (fname, ftype, fid) = iprot.readFieldBegin()
14494 
      if ftype == TType.STOP:
14495 
        break
14496 
      if fid == 0:
14497 
        if ftype == TType.I64:
14498 
          self.success = iprot.readI64();
14499 
        else:
14500 
          iprot.skip(ftype)
14501 
      else:
14502 
        iprot.skip(ftype)
14503 
      iprot.readFieldEnd()
14504 
    iprot.readStructEnd()
14505 
 
14506 
  def write(self, oprot):
14507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14509 
      return
14510 
    oprot.writeStructBegin('checkSimilarItem_result')
14511 
    if self.success is not None:
14512 
      oprot.writeFieldBegin('success', TType.I64, 0)
14513 
      oprot.writeI64(self.success)
14514 
      oprot.writeFieldEnd()
14515 
    oprot.writeFieldStop()
14516 
    oprot.writeStructEnd()
14517 
 
14518 
  def validate(self):
14519 
    return
14520 
 
14521 
 
14522 
  def __repr__(self):
14523 
    L = ['%s=%r' % (key, value)
14524 
      for key, value in self.__dict__.iteritems()]
14525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14526 
 
14527 
  def __eq__(self, other):
14528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14529 
 
14530 
  def __ne__(self, other):
14531 
    return not (self == other)
14532 
 
14533 
class validateRiskyStatus_args:
14534 
  """
14535 
  Attributes:
14536 
   - itemId
14537 
  """
14538 
 
14539 
  thrift_spec = (
14540 
    None, # 0
14541 
    (1, TType.I64, 'itemId', None, None, ), # 1
14542 
  )
14543 
 
14544 
  def __init__(self, itemId=None,):
14545 
    self.itemId = itemId
14546 
 
14547 
  def read(self, iprot):
14548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14550 
      return
14551 
    iprot.readStructBegin()
14552 
    while True:
14553 
      (fname, ftype, fid) = iprot.readFieldBegin()
14554 
      if ftype == TType.STOP:
14555 
        break
14556 
      if fid == 1:
14557 
        if ftype == TType.I64:
14558 
          self.itemId = iprot.readI64();
14559 
        else:
14560 
          iprot.skip(ftype)
14561 
      else:
14562 
        iprot.skip(ftype)
14563 
      iprot.readFieldEnd()
14564 
    iprot.readStructEnd()
14565 
 
14566 
  def write(self, oprot):
14567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14569 
      return
14570 
    oprot.writeStructBegin('validateRiskyStatus_args')
14571 
    if self.itemId is not None:
14572 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14573 
      oprot.writeI64(self.itemId)
14574 
      oprot.writeFieldEnd()
14575 
    oprot.writeFieldStop()
14576 
    oprot.writeStructEnd()
14577 
 
14578 
  def validate(self):
14579 
    return
14580 
 
14581 
 
14582 
  def __repr__(self):
14583 
    L = ['%s=%r' % (key, value)
14584 
      for key, value in self.__dict__.iteritems()]
14585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14586 
 
14587 
  def __eq__(self, other):
14588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14589 
 
14590 
  def __ne__(self, other):
14591 
    return not (self == other)
14592 
 
14593 
class validateRiskyStatus_result:
14594 
 
14595 
  thrift_spec = (
14596 
  )
14597 
 
14598 
  def read(self, iprot):
14599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14601 
      return
14602 
    iprot.readStructBegin()
14603 
    while True:
14604 
      (fname, ftype, fid) = iprot.readFieldBegin()
14605 
      if ftype == TType.STOP:
14606 
        break
14607 
      else:
14608 
        iprot.skip(ftype)
14609 
      iprot.readFieldEnd()
14610 
    iprot.readStructEnd()
14611 
 
14612 
  def write(self, oprot):
14613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14615 
      return
14616 
    oprot.writeStructBegin('validateRiskyStatus_result')
14617 
    oprot.writeFieldStop()
14618 
    oprot.writeStructEnd()
14619 
 
14620 
  def validate(self):
14621 
    return
14622 
 
14623 
 
14624 
  def __repr__(self):
14625 
    L = ['%s=%r' % (key, value)
14626 
      for key, value in self.__dict__.iteritems()]
14627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14628 
 
14629 
  def __eq__(self, other):
14630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14631 
 
14632 
  def __ne__(self, other):
14633 
    return not (self == other)
14634 
 
14635 
class changeItemRiskyFlag_args:
14636 
  """
14637 
  Attributes:
14638 
   - itemId
14639 
   - risky
14640 
  """
14641 
 
14642 
  thrift_spec = (
14643 
    None, # 0
14644 
    (1, TType.I64, 'itemId', None, None, ), # 1
14645 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14646 
  )
14647 
 
14648 
  def __init__(self, itemId=None, risky=None,):
14649 
    self.itemId = itemId
14650 
    self.risky = risky
14651 
 
14652 
  def read(self, iprot):
14653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14655 
      return
14656 
    iprot.readStructBegin()
14657 
    while True:
14658 
      (fname, ftype, fid) = iprot.readFieldBegin()
14659 
      if ftype == TType.STOP:
14660 
        break
14661 
      if fid == 1:
14662 
        if ftype == TType.I64:
14663 
          self.itemId = iprot.readI64();
14664 
        else:
14665 
          iprot.skip(ftype)
14666 
      elif fid == 2:
14667 
        if ftype == TType.BOOL:
14668 
          self.risky = iprot.readBool();
14669 
        else:
14670 
          iprot.skip(ftype)
14671 
      else:
14672 
        iprot.skip(ftype)
14673 
      iprot.readFieldEnd()
14674 
    iprot.readStructEnd()
14675 
 
14676 
  def write(self, oprot):
14677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14679 
      return
14680 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14681 
    if self.itemId is not None:
14682 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14683 
      oprot.writeI64(self.itemId)
14684 
      oprot.writeFieldEnd()
14685 
    if self.risky is not None:
14686 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14687 
      oprot.writeBool(self.risky)
14688 
      oprot.writeFieldEnd()
14689 
    oprot.writeFieldStop()
14690 
    oprot.writeStructEnd()
14691 
 
14692 
  def validate(self):
14693 
    return
14694 
 
14695 
 
14696 
  def __repr__(self):
14697 
    L = ['%s=%r' % (key, value)
14698 
      for key, value in self.__dict__.iteritems()]
14699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14700 
 
14701 
  def __eq__(self, other):
14702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14703 
 
14704 
  def __ne__(self, other):
14705 
    return not (self == other)
14706 
 
14707 
class changeItemRiskyFlag_result:
14708 
 
14709 
  thrift_spec = (
14710 
  )
14711 
 
14712 
  def read(self, iprot):
14713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14715 
      return
14716 
    iprot.readStructBegin()
14717 
    while True:
14718 
      (fname, ftype, fid) = iprot.readFieldBegin()
14719 
      if ftype == TType.STOP:
14720 
        break
14721 
      else:
14722 
        iprot.skip(ftype)
14723 
      iprot.readFieldEnd()
14724 
    iprot.readStructEnd()
14725 
 
14726 
  def write(self, oprot):
14727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14729 
      return
14730 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14731 
    oprot.writeFieldStop()
14732 
    oprot.writeStructEnd()
14733 
 
14734 
  def validate(self):
14735 
    return
14736 
 
14737 
 
14738 
  def __repr__(self):
14739 
    L = ['%s=%r' % (key, value)
14740 
      for key, value in self.__dict__.iteritems()]
14741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14742 
 
14743 
  def __eq__(self, other):
14744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14745 
 
14746 
  def __ne__(self, other):
14747 
    return not (self == other)
14748 
 
14749 
class getItemsByRiskyFlag_args:
14750 
 
14751 
  thrift_spec = (
14752 
  )
14753 
 
14754 
  def read(self, iprot):
14755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14757 
      return
14758 
    iprot.readStructBegin()
14759 
    while True:
14760 
      (fname, ftype, fid) = iprot.readFieldBegin()
14761 
      if ftype == TType.STOP:
14762 
        break
14763 
      else:
14764 
        iprot.skip(ftype)
14765 
      iprot.readFieldEnd()
14766 
    iprot.readStructEnd()
14767 
 
14768 
  def write(self, oprot):
14769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14771 
      return
14772 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14773 
    oprot.writeFieldStop()
14774 
    oprot.writeStructEnd()
14775 
 
14776 
  def validate(self):
14777 
    return
14778 
 
14779 
 
14780 
  def __repr__(self):
14781 
    L = ['%s=%r' % (key, value)
14782 
      for key, value in self.__dict__.iteritems()]
14783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14784 
 
14785 
  def __eq__(self, other):
14786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14787 
 
14788 
  def __ne__(self, other):
14789 
    return not (self == other)
14790 
 
14791 
class getItemsByRiskyFlag_result:
14792 
  """
14793 
  Attributes:
14794 
   - success
14795 
  """
14796 
 
14797 
  thrift_spec = (
14798 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14799 
  )
14800 
 
14801 
  def __init__(self, success=None,):
14802 
    self.success = success
14803 
 
14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
14813 
      if fid == 0:
14814 
        if ftype == TType.LIST:
14815 
          self.success = []
9155 kshitij.so 14816 
          (_etype279, _size276) = iprot.readListBegin()
14817 
          for _i280 in xrange(_size276):
14818 
            _elem281 = Item()
14819 
            _elem281.read(iprot)
14820 
            self.success.append(_elem281)
5944 mandeep.dh 14821 
          iprot.readListEnd()
14822 
        else:
14823 
          iprot.skip(ftype)
14824 
      else:
14825 
        iprot.skip(ftype)
14826 
      iprot.readFieldEnd()
14827 
    iprot.readStructEnd()
14828 
 
14829 
  def write(self, oprot):
14830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14832 
      return
14833 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14834 
    if self.success is not None:
14835 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14836 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14837 
      for iter282 in self.success:
14838 
        iter282.write(oprot)
5944 mandeep.dh 14839 
      oprot.writeListEnd()
14840 
      oprot.writeFieldEnd()
14841 
    oprot.writeFieldStop()
14842 
    oprot.writeStructEnd()
14843 
 
14844 
  def validate(self):
14845 
    return
14846 
 
14847 
 
14848 
  def __repr__(self):
14849 
    L = ['%s=%r' % (key, value)
14850 
      for key, value in self.__dict__.iteritems()]
14851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14852 
 
14853 
  def __eq__(self, other):
14854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14855 
 
14856 
  def __ne__(self, other):
14857 
    return not (self == other)
14858 
 
14859 
class getItemsForMasterSheet_args:
14860 
  """
14861 
  Attributes:
14862 
   - category
14863 
   - brand
14864 
  """
14865 
 
14866 
  thrift_spec = (
14867 
    None, # 0
14868 
    (1, TType.STRING, 'category', None, None, ), # 1
14869 
    (2, TType.STRING, 'brand', None, None, ), # 2
14870 
  )
14871 
 
14872 
  def __init__(self, category=None, brand=None,):
14873 
    self.category = category
14874 
    self.brand = brand
14875 
 
14876 
  def read(self, iprot):
14877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14879 
      return
14880 
    iprot.readStructBegin()
14881 
    while True:
14882 
      (fname, ftype, fid) = iprot.readFieldBegin()
14883 
      if ftype == TType.STOP:
14884 
        break
14885 
      if fid == 1:
14886 
        if ftype == TType.STRING:
14887 
          self.category = iprot.readString();
14888 
        else:
14889 
          iprot.skip(ftype)
14890 
      elif fid == 2:
14891 
        if ftype == TType.STRING:
14892 
          self.brand = iprot.readString();
14893 
        else:
14894 
          iprot.skip(ftype)
14895 
      else:
14896 
        iprot.skip(ftype)
14897 
      iprot.readFieldEnd()
14898 
    iprot.readStructEnd()
14899 
 
14900 
  def write(self, oprot):
14901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14903 
      return
14904 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14905 
    if self.category is not None:
14906 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14907 
      oprot.writeString(self.category)
14908 
      oprot.writeFieldEnd()
14909 
    if self.brand is not None:
14910 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14911 
      oprot.writeString(self.brand)
14912 
      oprot.writeFieldEnd()
14913 
    oprot.writeFieldStop()
14914 
    oprot.writeStructEnd()
14915 
 
14916 
  def validate(self):
14917 
    return
14918 
 
14919 
 
14920 
  def __repr__(self):
14921 
    L = ['%s=%r' % (key, value)
14922 
      for key, value in self.__dict__.iteritems()]
14923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14924 
 
14925 
  def __eq__(self, other):
14926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14927 
 
14928 
  def __ne__(self, other):
14929 
    return not (self == other)
14930 
 
14931 
class getItemsForMasterSheet_result:
14932 
  """
14933 
  Attributes:
14934 
   - success
14935 
  """
14936 
 
14937 
  thrift_spec = (
14938 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14939 
  )
14940 
 
14941 
  def __init__(self, success=None,):
14942 
    self.success = success
14943 
 
14944 
  def read(self, iprot):
14945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14947 
      return
14948 
    iprot.readStructBegin()
14949 
    while True:
14950 
      (fname, ftype, fid) = iprot.readFieldBegin()
14951 
      if ftype == TType.STOP:
14952 
        break
14953 
      if fid == 0:
14954 
        if ftype == TType.LIST:
14955 
          self.success = []
9155 kshitij.so 14956 
          (_etype286, _size283) = iprot.readListBegin()
14957 
          for _i287 in xrange(_size283):
14958 
            _elem288 = Item()
14959 
            _elem288.read(iprot)
14960 
            self.success.append(_elem288)
5944 mandeep.dh 14961 
          iprot.readListEnd()
14962 
        else:
14963 
          iprot.skip(ftype)
14964 
      else:
14965 
        iprot.skip(ftype)
14966 
      iprot.readFieldEnd()
14967 
    iprot.readStructEnd()
14968 
 
14969 
  def write(self, oprot):
14970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14972 
      return
14973 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14974 
    if self.success is not None:
14975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14976 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14977 
      for iter289 in self.success:
14978 
        iter289.write(oprot)
5944 mandeep.dh 14979 
      oprot.writeListEnd()
14980 
      oprot.writeFieldEnd()
14981 
    oprot.writeFieldStop()
14982 
    oprot.writeStructEnd()
14983 
 
14984 
  def validate(self):
14985 
    return
14986 
 
14987 
 
14988 
  def __repr__(self):
14989 
    L = ['%s=%r' % (key, value)
14990 
      for key, value in self.__dict__.iteritems()]
14991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14992 
 
14993 
  def __eq__(self, other):
14994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14995 
 
14996 
  def __ne__(self, other):
14997 
    return not (self == other)
14998 
 
14999 
class getSimilarItemsCatalogIds_args:
15000 
  """
15001 
  Attributes:
15002 
   - beginIndex
15003 
   - totalItems
15004 
   - itemId
15005 
  """
15006 
 
15007 
  thrift_spec = (
15008 
    None, # 0
15009 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15010 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15011 
    (3, TType.I64, 'itemId', None, None, ), # 3
15012 
  )
15013 
 
15014 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15015 
    self.beginIndex = beginIndex
15016 
    self.totalItems = totalItems
15017 
    self.itemId = itemId
15018 
 
15019 
  def read(self, iprot):
15020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15022 
      return
15023 
    iprot.readStructBegin()
15024 
    while True:
15025 
      (fname, ftype, fid) = iprot.readFieldBegin()
15026 
      if ftype == TType.STOP:
15027 
        break
15028 
      if fid == 1:
15029 
        if ftype == TType.I64:
15030 
          self.beginIndex = iprot.readI64();
15031 
        else:
15032 
          iprot.skip(ftype)
15033 
      elif fid == 2:
15034 
        if ftype == TType.I64:
15035 
          self.totalItems = iprot.readI64();
15036 
        else:
15037 
          iprot.skip(ftype)
15038 
      elif fid == 3:
15039 
        if ftype == TType.I64:
15040 
          self.itemId = iprot.readI64();
15041 
        else:
15042 
          iprot.skip(ftype)
15043 
      else:
15044 
        iprot.skip(ftype)
15045 
      iprot.readFieldEnd()
15046 
    iprot.readStructEnd()
15047 
 
15048 
  def write(self, oprot):
15049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15051 
      return
15052 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15053 
    if self.beginIndex is not None:
15054 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15055 
      oprot.writeI64(self.beginIndex)
15056 
      oprot.writeFieldEnd()
15057 
    if self.totalItems is not None:
15058 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15059 
      oprot.writeI64(self.totalItems)
15060 
      oprot.writeFieldEnd()
15061 
    if self.itemId is not None:
15062 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15063 
      oprot.writeI64(self.itemId)
15064 
      oprot.writeFieldEnd()
15065 
    oprot.writeFieldStop()
15066 
    oprot.writeStructEnd()
15067 
 
15068 
  def validate(self):
15069 
    return
15070 
 
15071 
 
15072 
  def __repr__(self):
15073 
    L = ['%s=%r' % (key, value)
15074 
      for key, value in self.__dict__.iteritems()]
15075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15076 
 
15077 
  def __eq__(self, other):
15078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15079 
 
15080 
  def __ne__(self, other):
15081 
    return not (self == other)
15082 
 
15083 
class getSimilarItemsCatalogIds_result:
15084 
  """
15085 
  Attributes:
15086 
   - success
15087 
  """
15088 
 
15089 
  thrift_spec = (
15090 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15091 
  )
15092 
 
15093 
  def __init__(self, success=None,):
15094 
    self.success = success
15095 
 
15096 
  def read(self, iprot):
15097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15099 
      return
15100 
    iprot.readStructBegin()
15101 
    while True:
15102 
      (fname, ftype, fid) = iprot.readFieldBegin()
15103 
      if ftype == TType.STOP:
15104 
        break
15105 
      if fid == 0:
15106 
        if ftype == TType.LIST:
15107 
          self.success = []
9155 kshitij.so 15108 
          (_etype293, _size290) = iprot.readListBegin()
15109 
          for _i294 in xrange(_size290):
15110 
            _elem295 = iprot.readI64();
15111 
            self.success.append(_elem295)
5944 mandeep.dh 15112 
          iprot.readListEnd()
15113 
        else:
15114 
          iprot.skip(ftype)
15115 
      else:
15116 
        iprot.skip(ftype)
15117 
      iprot.readFieldEnd()
15118 
    iprot.readStructEnd()
15119 
 
15120 
  def write(self, oprot):
15121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15123 
      return
15124 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15125 
    if self.success is not None:
15126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15127 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15128 
      for iter296 in self.success:
15129 
        oprot.writeI64(iter296)
5944 mandeep.dh 15130 
      oprot.writeListEnd()
15131 
      oprot.writeFieldEnd()
15132 
    oprot.writeFieldStop()
15133 
    oprot.writeStructEnd()
15134 
 
15135 
  def validate(self):
15136 
    return
15137 
 
15138 
 
15139 
  def __repr__(self):
15140 
    L = ['%s=%r' % (key, value)
15141 
      for key, value in self.__dict__.iteritems()]
15142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15143 
 
15144 
  def __eq__(self, other):
15145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15146 
 
15147 
  def __ne__(self, other):
15148 
    return not (self == other)
15149 
 
15150 
class addProductNotification_args:
15151 
  """
15152 
  Attributes:
15153 
   - itemId
15154 
   - email
15155 
  """
15156 
 
15157 
  thrift_spec = None
15158 
  def __init__(self, itemId=None, email=None,):
15159 
    self.itemId = itemId
15160 
    self.email = email
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == -1:
15172 
        if ftype == TType.I64:
15173 
          self.itemId = iprot.readI64();
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      elif fid == -2:
15177 
        if ftype == TType.STRING:
15178 
          self.email = iprot.readString();
15179 
        else:
15180 
          iprot.skip(ftype)
15181 
      else:
15182 
        iprot.skip(ftype)
15183 
      iprot.readFieldEnd()
15184 
    iprot.readStructEnd()
15185 
 
15186 
  def write(self, oprot):
15187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15189 
      return
15190 
    oprot.writeStructBegin('addProductNotification_args')
15191 
    if self.email is not None:
15192 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15193 
      oprot.writeString(self.email)
15194 
      oprot.writeFieldEnd()
15195 
    if self.itemId is not None:
15196 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15197 
      oprot.writeI64(self.itemId)
15198 
      oprot.writeFieldEnd()
15199 
    oprot.writeFieldStop()
15200 
    oprot.writeStructEnd()
15201 
 
15202 
  def validate(self):
15203 
    return
15204 
 
15205 
 
15206 
  def __repr__(self):
15207 
    L = ['%s=%r' % (key, value)
15208 
      for key, value in self.__dict__.iteritems()]
15209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15210 
 
15211 
  def __eq__(self, other):
15212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15213 
 
15214 
  def __ne__(self, other):
15215 
    return not (self == other)
15216 
 
15217 
class addProductNotification_result:
15218 
  """
15219 
  Attributes:
15220 
   - success
15221 
  """
15222 
 
15223 
  thrift_spec = (
15224 
    (0, TType.BOOL, 'success', None, None, ), # 0
15225 
  )
15226 
 
15227 
  def __init__(self, success=None,):
15228 
    self.success = success
15229 
 
15230 
  def read(self, iprot):
15231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15233 
      return
15234 
    iprot.readStructBegin()
15235 
    while True:
15236 
      (fname, ftype, fid) = iprot.readFieldBegin()
15237 
      if ftype == TType.STOP:
15238 
        break
15239 
      if fid == 0:
15240 
        if ftype == TType.BOOL:
15241 
          self.success = iprot.readBool();
15242 
        else:
15243 
          iprot.skip(ftype)
15244 
      else:
15245 
        iprot.skip(ftype)
15246 
      iprot.readFieldEnd()
15247 
    iprot.readStructEnd()
15248 
 
15249 
  def write(self, oprot):
15250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15252 
      return
15253 
    oprot.writeStructBegin('addProductNotification_result')
15254 
    if self.success is not None:
15255 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15256 
      oprot.writeBool(self.success)
15257 
      oprot.writeFieldEnd()
15258 
    oprot.writeFieldStop()
15259 
    oprot.writeStructEnd()
15260 
 
15261 
  def validate(self):
15262 
    return
15263 
 
15264 
 
15265 
  def __repr__(self):
15266 
    L = ['%s=%r' % (key, value)
15267 
      for key, value in self.__dict__.iteritems()]
15268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15269 
 
15270 
  def __eq__(self, other):
15271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15272 
 
15273 
  def __ne__(self, other):
15274 
    return not (self == other)
15275 
 
15276 
class sendProductNotifications_args:
15277 
 
15278 
  thrift_spec = (
15279 
  )
15280 
 
15281 
  def read(self, iprot):
15282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15284 
      return
15285 
    iprot.readStructBegin()
15286 
    while True:
15287 
      (fname, ftype, fid) = iprot.readFieldBegin()
15288 
      if ftype == TType.STOP:
15289 
        break
15290 
      else:
15291 
        iprot.skip(ftype)
15292 
      iprot.readFieldEnd()
15293 
    iprot.readStructEnd()
15294 
 
15295 
  def write(self, oprot):
15296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15298 
      return
15299 
    oprot.writeStructBegin('sendProductNotifications_args')
15300 
    oprot.writeFieldStop()
15301 
    oprot.writeStructEnd()
15302 
 
15303 
  def validate(self):
15304 
    return
15305 
 
15306 
 
15307 
  def __repr__(self):
15308 
    L = ['%s=%r' % (key, value)
15309 
      for key, value in self.__dict__.iteritems()]
15310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15311 
 
15312 
  def __eq__(self, other):
15313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15314 
 
15315 
  def __ne__(self, other):
15316 
    return not (self == other)
15317 
 
15318 
class sendProductNotifications_result:
15319 
  """
15320 
  Attributes:
15321 
   - success
15322 
  """
15323 
 
15324 
  thrift_spec = (
15325 
    (0, TType.BOOL, 'success', None, None, ), # 0
15326 
  )
15327 
 
15328 
  def __init__(self, success=None,):
15329 
    self.success = success
15330 
 
15331 
  def read(self, iprot):
15332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15334 
      return
15335 
    iprot.readStructBegin()
15336 
    while True:
15337 
      (fname, ftype, fid) = iprot.readFieldBegin()
15338 
      if ftype == TType.STOP:
15339 
        break
15340 
      if fid == 0:
15341 
        if ftype == TType.BOOL:
15342 
          self.success = iprot.readBool();
15343 
        else:
15344 
          iprot.skip(ftype)
15345 
      else:
15346 
        iprot.skip(ftype)
15347 
      iprot.readFieldEnd()
15348 
    iprot.readStructEnd()
15349 
 
15350 
  def write(self, oprot):
15351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15353 
      return
15354 
    oprot.writeStructBegin('sendProductNotifications_result')
15355 
    if self.success is not None:
15356 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15357 
      oprot.writeBool(self.success)
15358 
      oprot.writeFieldEnd()
15359 
    oprot.writeFieldStop()
15360 
    oprot.writeStructEnd()
15361 
 
15362 
  def validate(self):
15363 
    return
15364 
 
15365 
 
15366 
  def __repr__(self):
15367 
    L = ['%s=%r' % (key, value)
15368 
      for key, value in self.__dict__.iteritems()]
15369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15370 
 
15371 
  def __eq__(self, other):
15372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15373 
 
15374 
  def __ne__(self, other):
15375 
    return not (self == other)
15376 
 
15377 
class getAllBrandsByCategory_args:
15378 
  """
15379 
  Attributes:
15380 
   - categoryId
15381 
  """
15382 
 
15383 
  thrift_spec = (
15384 
    None, # 0
15385 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15386 
  )
15387 
 
15388 
  def __init__(self, categoryId=None,):
15389 
    self.categoryId = categoryId
15390 
 
15391 
  def read(self, iprot):
15392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15394 
      return
15395 
    iprot.readStructBegin()
15396 
    while True:
15397 
      (fname, ftype, fid) = iprot.readFieldBegin()
15398 
      if ftype == TType.STOP:
15399 
        break
15400 
      if fid == 1:
15401 
        if ftype == TType.I64:
15402 
          self.categoryId = iprot.readI64();
15403 
        else:
15404 
          iprot.skip(ftype)
15405 
      else:
15406 
        iprot.skip(ftype)
15407 
      iprot.readFieldEnd()
15408 
    iprot.readStructEnd()
15409 
 
15410 
  def write(self, oprot):
15411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15413 
      return
15414 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15415 
    if self.categoryId is not None:
15416 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15417 
      oprot.writeI64(self.categoryId)
15418 
      oprot.writeFieldEnd()
15419 
    oprot.writeFieldStop()
15420 
    oprot.writeStructEnd()
15421 
 
15422 
  def validate(self):
15423 
    return
15424 
 
15425 
 
15426 
  def __repr__(self):
15427 
    L = ['%s=%r' % (key, value)
15428 
      for key, value in self.__dict__.iteritems()]
15429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15430 
 
15431 
  def __eq__(self, other):
15432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15433 
 
15434 
  def __ne__(self, other):
15435 
    return not (self == other)
15436 
 
15437 
class getAllBrandsByCategory_result:
15438 
  """
15439 
  Attributes:
15440 
   - success
15441 
  """
15442 
 
15443 
  thrift_spec = (
15444 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15445 
  )
15446 
 
15447 
  def __init__(self, success=None,):
15448 
    self.success = success
15449 
 
15450 
  def read(self, iprot):
15451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15453 
      return
15454 
    iprot.readStructBegin()
15455 
    while True:
15456 
      (fname, ftype, fid) = iprot.readFieldBegin()
15457 
      if ftype == TType.STOP:
15458 
        break
15459 
      if fid == 0:
15460 
        if ftype == TType.LIST:
15461 
          self.success = []
9155 kshitij.so 15462 
          (_etype300, _size297) = iprot.readListBegin()
15463 
          for _i301 in xrange(_size297):
15464 
            _elem302 = iprot.readString();
15465 
            self.success.append(_elem302)
5944 mandeep.dh 15466 
          iprot.readListEnd()
15467 
        else:
15468 
          iprot.skip(ftype)
15469 
      else:
15470 
        iprot.skip(ftype)
15471 
      iprot.readFieldEnd()
15472 
    iprot.readStructEnd()
15473 
 
15474 
  def write(self, oprot):
15475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15477 
      return
15478 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15479 
    if self.success is not None:
15480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15481 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15482 
      for iter303 in self.success:
15483 
        oprot.writeString(iter303)
5944 mandeep.dh 15484 
      oprot.writeListEnd()
15485 
      oprot.writeFieldEnd()
15486 
    oprot.writeFieldStop()
15487 
    oprot.writeStructEnd()
15488 
 
15489 
  def validate(self):
15490 
    return
15491 
 
15492 
 
15493 
  def __repr__(self):
15494 
    L = ['%s=%r' % (key, value)
15495 
      for key, value in self.__dict__.iteritems()]
15496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15497 
 
15498 
  def __eq__(self, other):
15499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15500 
 
15501 
  def __ne__(self, other):
15502 
    return not (self == other)
15503 
 
15504 
class getAllBrands_args:
15505 
 
15506 
  thrift_spec = (
15507 
  )
15508 
 
15509 
  def read(self, iprot):
15510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15512 
      return
15513 
    iprot.readStructBegin()
15514 
    while True:
15515 
      (fname, ftype, fid) = iprot.readFieldBegin()
15516 
      if ftype == TType.STOP:
15517 
        break
15518 
      else:
15519 
        iprot.skip(ftype)
15520 
      iprot.readFieldEnd()
15521 
    iprot.readStructEnd()
15522 
 
15523 
  def write(self, oprot):
15524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15526 
      return
15527 
    oprot.writeStructBegin('getAllBrands_args')
15528 
    oprot.writeFieldStop()
15529 
    oprot.writeStructEnd()
15530 
 
15531 
  def validate(self):
15532 
    return
15533 
 
15534 
 
15535 
  def __repr__(self):
15536 
    L = ['%s=%r' % (key, value)
15537 
      for key, value in self.__dict__.iteritems()]
15538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15539 
 
15540 
  def __eq__(self, other):
15541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15542 
 
15543 
  def __ne__(self, other):
15544 
    return not (self == other)
15545 
 
15546 
class getAllBrands_result:
15547 
  """
15548 
  Attributes:
15549 
   - success
15550 
  """
15551 
 
15552 
  thrift_spec = (
15553 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15554 
  )
15555 
 
15556 
  def __init__(self, success=None,):
15557 
    self.success = success
15558 
 
15559 
  def read(self, iprot):
15560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15562 
      return
15563 
    iprot.readStructBegin()
15564 
    while True:
15565 
      (fname, ftype, fid) = iprot.readFieldBegin()
15566 
      if ftype == TType.STOP:
15567 
        break
15568 
      if fid == 0:
15569 
        if ftype == TType.LIST:
15570 
          self.success = []
9155 kshitij.so 15571 
          (_etype307, _size304) = iprot.readListBegin()
15572 
          for _i308 in xrange(_size304):
15573 
            _elem309 = iprot.readString();
15574 
            self.success.append(_elem309)
5944 mandeep.dh 15575 
          iprot.readListEnd()
15576 
        else:
15577 
          iprot.skip(ftype)
15578 
      else:
15579 
        iprot.skip(ftype)
15580 
      iprot.readFieldEnd()
15581 
    iprot.readStructEnd()
15582 
 
15583 
  def write(self, oprot):
15584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15586 
      return
15587 
    oprot.writeStructBegin('getAllBrands_result')
15588 
    if self.success is not None:
15589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15590 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15591 
      for iter310 in self.success:
15592 
        oprot.writeString(iter310)
5944 mandeep.dh 15593 
      oprot.writeListEnd()
15594 
      oprot.writeFieldEnd()
15595 
    oprot.writeFieldStop()
15596 
    oprot.writeStructEnd()
15597 
 
15598 
  def validate(self):
15599 
    return
15600 
 
15601 
 
15602 
  def __repr__(self):
15603 
    L = ['%s=%r' % (key, value)
15604 
      for key, value in self.__dict__.iteritems()]
15605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15606 
 
15607 
  def __eq__(self, other):
15608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15609 
 
15610 
  def __ne__(self, other):
15611 
    return not (self == other)
15612 
 
15613 
class getAllSources_args:
15614 
 
15615 
  thrift_spec = (
15616 
  )
15617 
 
15618 
  def read(self, iprot):
15619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15621 
      return
15622 
    iprot.readStructBegin()
15623 
    while True:
15624 
      (fname, ftype, fid) = iprot.readFieldBegin()
15625 
      if ftype == TType.STOP:
15626 
        break
15627 
      else:
15628 
        iprot.skip(ftype)
15629 
      iprot.readFieldEnd()
15630 
    iprot.readStructEnd()
15631 
 
15632 
  def write(self, oprot):
15633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15635 
      return
15636 
    oprot.writeStructBegin('getAllSources_args')
15637 
    oprot.writeFieldStop()
15638 
    oprot.writeStructEnd()
15639 
 
15640 
  def validate(self):
15641 
    return
15642 
 
15643 
 
15644 
  def __repr__(self):
15645 
    L = ['%s=%r' % (key, value)
15646 
      for key, value in self.__dict__.iteritems()]
15647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15648 
 
15649 
  def __eq__(self, other):
15650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15651 
 
15652 
  def __ne__(self, other):
15653 
    return not (self == other)
15654 
 
15655 
class getAllSources_result:
15656 
  """
15657 
  Attributes:
15658 
   - success
15659 
  """
15660 
 
15661 
  thrift_spec = (
15662 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15663 
  )
15664 
 
15665 
  def __init__(self, success=None,):
15666 
    self.success = success
15667 
 
15668 
  def read(self, iprot):
15669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15671 
      return
15672 
    iprot.readStructBegin()
15673 
    while True:
15674 
      (fname, ftype, fid) = iprot.readFieldBegin()
15675 
      if ftype == TType.STOP:
15676 
        break
15677 
      if fid == 0:
15678 
        if ftype == TType.LIST:
15679 
          self.success = []
9155 kshitij.so 15680 
          (_etype314, _size311) = iprot.readListBegin()
15681 
          for _i315 in xrange(_size311):
15682 
            _elem316 = Source()
15683 
            _elem316.read(iprot)
15684 
            self.success.append(_elem316)
5944 mandeep.dh 15685 
          iprot.readListEnd()
15686 
        else:
15687 
          iprot.skip(ftype)
15688 
      else:
15689 
        iprot.skip(ftype)
15690 
      iprot.readFieldEnd()
15691 
    iprot.readStructEnd()
15692 
 
15693 
  def write(self, oprot):
15694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15696 
      return
15697 
    oprot.writeStructBegin('getAllSources_result')
15698 
    if self.success is not None:
15699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15701 
      for iter317 in self.success:
15702 
        iter317.write(oprot)
5944 mandeep.dh 15703 
      oprot.writeListEnd()
15704 
      oprot.writeFieldEnd()
15705 
    oprot.writeFieldStop()
15706 
    oprot.writeStructEnd()
15707 
 
15708 
  def validate(self):
15709 
    return
15710 
 
15711 
 
15712 
  def __repr__(self):
15713 
    L = ['%s=%r' % (key, value)
15714 
      for key, value in self.__dict__.iteritems()]
15715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15716 
 
15717 
  def __eq__(self, other):
15718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15719 
 
15720 
  def __ne__(self, other):
15721 
    return not (self == other)
15722 
 
15723 
class getItemPricingBySource_args:
15724 
  """
15725 
  Attributes:
15726 
   - itemId
15727 
   - sourceId
15728 
  """
15729 
 
15730 
  thrift_spec = (
15731 
    None, # 0
15732 
    (1, TType.I64, 'itemId', None, None, ), # 1
15733 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15734 
  )
15735 
 
15736 
  def __init__(self, itemId=None, sourceId=None,):
15737 
    self.itemId = itemId
15738 
    self.sourceId = sourceId
15739 
 
15740 
  def read(self, iprot):
15741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15743 
      return
15744 
    iprot.readStructBegin()
15745 
    while True:
15746 
      (fname, ftype, fid) = iprot.readFieldBegin()
15747 
      if ftype == TType.STOP:
15748 
        break
15749 
      if fid == 1:
15750 
        if ftype == TType.I64:
15751 
          self.itemId = iprot.readI64();
15752 
        else:
15753 
          iprot.skip(ftype)
15754 
      elif fid == 2:
15755 
        if ftype == TType.I64:
15756 
          self.sourceId = iprot.readI64();
15757 
        else:
15758 
          iprot.skip(ftype)
15759 
      else:
15760 
        iprot.skip(ftype)
15761 
      iprot.readFieldEnd()
15762 
    iprot.readStructEnd()
15763 
 
15764 
  def write(self, oprot):
15765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15767 
      return
15768 
    oprot.writeStructBegin('getItemPricingBySource_args')
15769 
    if self.itemId is not None:
15770 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15771 
      oprot.writeI64(self.itemId)
15772 
      oprot.writeFieldEnd()
15773 
    if self.sourceId is not None:
15774 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15775 
      oprot.writeI64(self.sourceId)
15776 
      oprot.writeFieldEnd()
15777 
    oprot.writeFieldStop()
15778 
    oprot.writeStructEnd()
15779 
 
15780 
  def validate(self):
15781 
    return
15782 
 
15783 
 
15784 
  def __repr__(self):
15785 
    L = ['%s=%r' % (key, value)
15786 
      for key, value in self.__dict__.iteritems()]
15787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15788 
 
15789 
  def __eq__(self, other):
15790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15791 
 
15792 
  def __ne__(self, other):
15793 
    return not (self == other)
15794 
 
15795 
class getItemPricingBySource_result:
15796 
  """
15797 
  Attributes:
15798 
   - success
15799 
   - cex
15800 
  """
15801 
 
15802 
  thrift_spec = (
15803 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15804 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15805 
  )
15806 
 
15807 
  def __init__(self, success=None, cex=None,):
15808 
    self.success = success
15809 
    self.cex = cex
15810 
 
15811 
  def read(self, iprot):
15812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15814 
      return
15815 
    iprot.readStructBegin()
15816 
    while True:
15817 
      (fname, ftype, fid) = iprot.readFieldBegin()
15818 
      if ftype == TType.STOP:
15819 
        break
15820 
      if fid == 0:
15821 
        if ftype == TType.STRUCT:
15822 
          self.success = SourceItemPricing()
15823 
          self.success.read(iprot)
15824 
        else:
15825 
          iprot.skip(ftype)
15826 
      elif fid == 1:
15827 
        if ftype == TType.STRUCT:
15828 
          self.cex = CatalogServiceException()
15829 
          self.cex.read(iprot)
15830 
        else:
15831 
          iprot.skip(ftype)
15832 
      else:
15833 
        iprot.skip(ftype)
15834 
      iprot.readFieldEnd()
15835 
    iprot.readStructEnd()
15836 
 
15837 
  def write(self, oprot):
15838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15840 
      return
15841 
    oprot.writeStructBegin('getItemPricingBySource_result')
15842 
    if self.success is not None:
15843 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15844 
      self.success.write(oprot)
15845 
      oprot.writeFieldEnd()
15846 
    if self.cex is not None:
15847 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15848 
      self.cex.write(oprot)
15849 
      oprot.writeFieldEnd()
15850 
    oprot.writeFieldStop()
15851 
    oprot.writeStructEnd()
15852 
 
15853 
  def validate(self):
15854 
    return
15855 
 
15856 
 
15857 
  def __repr__(self):
15858 
    L = ['%s=%r' % (key, value)
15859 
      for key, value in self.__dict__.iteritems()]
15860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15861 
 
15862 
  def __eq__(self, other):
15863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15864 
 
15865 
  def __ne__(self, other):
15866 
    return not (self == other)
15867 
 
15868 
class addSourceItemPricing_args:
15869 
  """
15870 
  Attributes:
15871 
   - sourceItemPricing
15872 
  """
15873 
 
15874 
  thrift_spec = (
15875 
    None, # 0
15876 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15877 
  )
15878 
 
15879 
  def __init__(self, sourceItemPricing=None,):
15880 
    self.sourceItemPricing = sourceItemPricing
15881 
 
15882 
  def read(self, iprot):
15883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15885 
      return
15886 
    iprot.readStructBegin()
15887 
    while True:
15888 
      (fname, ftype, fid) = iprot.readFieldBegin()
15889 
      if ftype == TType.STOP:
15890 
        break
15891 
      if fid == 1:
15892 
        if ftype == TType.STRUCT:
15893 
          self.sourceItemPricing = SourceItemPricing()
15894 
          self.sourceItemPricing.read(iprot)
15895 
        else:
15896 
          iprot.skip(ftype)
15897 
      else:
15898 
        iprot.skip(ftype)
15899 
      iprot.readFieldEnd()
15900 
    iprot.readStructEnd()
15901 
 
15902 
  def write(self, oprot):
15903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15905 
      return
15906 
    oprot.writeStructBegin('addSourceItemPricing_args')
15907 
    if self.sourceItemPricing is not None:
15908 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15909 
      self.sourceItemPricing.write(oprot)
15910 
      oprot.writeFieldEnd()
15911 
    oprot.writeFieldStop()
15912 
    oprot.writeStructEnd()
15913 
 
15914 
  def validate(self):
15915 
    return
15916 
 
15917 
 
15918 
  def __repr__(self):
15919 
    L = ['%s=%r' % (key, value)
15920 
      for key, value in self.__dict__.iteritems()]
15921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15922 
 
15923 
  def __eq__(self, other):
15924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15925 
 
15926 
  def __ne__(self, other):
15927 
    return not (self == other)
15928 
 
15929 
class addSourceItemPricing_result:
15930 
  """
15931 
  Attributes:
15932 
   - cex
15933 
  """
15934 
 
15935 
  thrift_spec = (
15936 
    None, # 0
15937 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15938 
  )
15939 
 
15940 
  def __init__(self, cex=None,):
15941 
    self.cex = cex
15942 
 
15943 
  def read(self, iprot):
15944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15946 
      return
15947 
    iprot.readStructBegin()
15948 
    while True:
15949 
      (fname, ftype, fid) = iprot.readFieldBegin()
15950 
      if ftype == TType.STOP:
15951 
        break
15952 
      if fid == 1:
15953 
        if ftype == TType.STRUCT:
15954 
          self.cex = CatalogServiceException()
15955 
          self.cex.read(iprot)
15956 
        else:
15957 
          iprot.skip(ftype)
15958 
      else:
15959 
        iprot.skip(ftype)
15960 
      iprot.readFieldEnd()
15961 
    iprot.readStructEnd()
15962 
 
15963 
  def write(self, oprot):
15964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15966 
      return
15967 
    oprot.writeStructBegin('addSourceItemPricing_result')
15968 
    if self.cex is not None:
15969 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15970 
      self.cex.write(oprot)
15971 
      oprot.writeFieldEnd()
15972 
    oprot.writeFieldStop()
15973 
    oprot.writeStructEnd()
15974 
 
15975 
  def validate(self):
15976 
    return
15977 
 
15978 
 
15979 
  def __repr__(self):
15980 
    L = ['%s=%r' % (key, value)
15981 
      for key, value in self.__dict__.iteritems()]
15982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15983 
 
15984 
  def __eq__(self, other):
15985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15986 
 
15987 
  def __ne__(self, other):
15988 
    return not (self == other)
15989 
 
15990 
class getAllSourcePricing_args:
15991 
  """
15992 
  Attributes:
15993 
   - itemId
15994 
  """
15995 
 
15996 
  thrift_spec = (
15997 
    None, # 0
15998 
    (1, TType.I64, 'itemId', None, None, ), # 1
15999 
  )
16000 
 
16001 
  def __init__(self, itemId=None,):
16002 
    self.itemId = itemId
16003 
 
16004 
  def read(self, iprot):
16005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16007 
      return
16008 
    iprot.readStructBegin()
16009 
    while True:
16010 
      (fname, ftype, fid) = iprot.readFieldBegin()
16011 
      if ftype == TType.STOP:
16012 
        break
16013 
      if fid == 1:
16014 
        if ftype == TType.I64:
16015 
          self.itemId = iprot.readI64();
16016 
        else:
16017 
          iprot.skip(ftype)
16018 
      else:
16019 
        iprot.skip(ftype)
16020 
      iprot.readFieldEnd()
16021 
    iprot.readStructEnd()
16022 
 
16023 
  def write(self, oprot):
16024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16026 
      return
16027 
    oprot.writeStructBegin('getAllSourcePricing_args')
16028 
    if self.itemId is not None:
16029 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16030 
      oprot.writeI64(self.itemId)
16031 
      oprot.writeFieldEnd()
16032 
    oprot.writeFieldStop()
16033 
    oprot.writeStructEnd()
16034 
 
16035 
  def validate(self):
16036 
    return
16037 
 
16038 
 
16039 
  def __repr__(self):
16040 
    L = ['%s=%r' % (key, value)
16041 
      for key, value in self.__dict__.iteritems()]
16042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16043 
 
16044 
  def __eq__(self, other):
16045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16046 
 
16047 
  def __ne__(self, other):
16048 
    return not (self == other)
16049 
 
16050 
class getAllSourcePricing_result:
16051 
  """
16052 
  Attributes:
16053 
   - success
16054 
   - cex
16055 
  """
16056 
 
16057 
  thrift_spec = (
16058 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16059 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16060 
  )
16061 
 
16062 
  def __init__(self, success=None, cex=None,):
16063 
    self.success = success
16064 
    self.cex = cex
16065 
 
16066 
  def read(self, iprot):
16067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16069 
      return
16070 
    iprot.readStructBegin()
16071 
    while True:
16072 
      (fname, ftype, fid) = iprot.readFieldBegin()
16073 
      if ftype == TType.STOP:
16074 
        break
16075 
      if fid == 0:
16076 
        if ftype == TType.LIST:
16077 
          self.success = []
9155 kshitij.so 16078 
          (_etype321, _size318) = iprot.readListBegin()
16079 
          for _i322 in xrange(_size318):
16080 
            _elem323 = SourceItemPricing()
16081 
            _elem323.read(iprot)
16082 
            self.success.append(_elem323)
5944 mandeep.dh 16083 
          iprot.readListEnd()
16084 
        else:
16085 
          iprot.skip(ftype)
16086 
      elif fid == 1:
16087 
        if ftype == TType.STRUCT:
16088 
          self.cex = CatalogServiceException()
16089 
          self.cex.read(iprot)
16090 
        else:
16091 
          iprot.skip(ftype)
16092 
      else:
16093 
        iprot.skip(ftype)
16094 
      iprot.readFieldEnd()
16095 
    iprot.readStructEnd()
16096 
 
16097 
  def write(self, oprot):
16098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16100 
      return
16101 
    oprot.writeStructBegin('getAllSourcePricing_result')
16102 
    if self.success is not None:
16103 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16104 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16105 
      for iter324 in self.success:
16106 
        iter324.write(oprot)
5944 mandeep.dh 16107 
      oprot.writeListEnd()
16108 
      oprot.writeFieldEnd()
16109 
    if self.cex is not None:
16110 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16111 
      self.cex.write(oprot)
16112 
      oprot.writeFieldEnd()
16113 
    oprot.writeFieldStop()
16114 
    oprot.writeStructEnd()
16115 
 
16116 
  def validate(self):
16117 
    return
16118 
 
16119 
 
16120 
  def __repr__(self):
16121 
    L = ['%s=%r' % (key, value)
16122 
      for key, value in self.__dict__.iteritems()]
16123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16124 
 
16125 
  def __eq__(self, other):
16126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16127 
 
16128 
  def __ne__(self, other):
16129 
    return not (self == other)
16130 
 
16131 
class getItemForSource_args:
16132 
  """
16133 
  Attributes:
16134 
   - item_id
16135 
   - sourceId
16136 
  """
16137 
 
16138 
  thrift_spec = (
16139 
    None, # 0
16140 
    (1, TType.I64, 'item_id', None, None, ), # 1
16141 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16142 
  )
16143 
 
16144 
  def __init__(self, item_id=None, sourceId=None,):
16145 
    self.item_id = item_id
16146 
    self.sourceId = sourceId
16147 
 
16148 
  def read(self, iprot):
16149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16151 
      return
16152 
    iprot.readStructBegin()
16153 
    while True:
16154 
      (fname, ftype, fid) = iprot.readFieldBegin()
16155 
      if ftype == TType.STOP:
16156 
        break
16157 
      if fid == 1:
16158 
        if ftype == TType.I64:
16159 
          self.item_id = iprot.readI64();
16160 
        else:
16161 
          iprot.skip(ftype)
16162 
      elif fid == 2:
16163 
        if ftype == TType.I64:
16164 
          self.sourceId = iprot.readI64();
16165 
        else:
16166 
          iprot.skip(ftype)
16167 
      else:
16168 
        iprot.skip(ftype)
16169 
      iprot.readFieldEnd()
16170 
    iprot.readStructEnd()
16171 
 
16172 
  def write(self, oprot):
16173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16175 
      return
16176 
    oprot.writeStructBegin('getItemForSource_args')
16177 
    if self.item_id is not None:
16178 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16179 
      oprot.writeI64(self.item_id)
16180 
      oprot.writeFieldEnd()
16181 
    if self.sourceId is not None:
16182 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16183 
      oprot.writeI64(self.sourceId)
16184 
      oprot.writeFieldEnd()
16185 
    oprot.writeFieldStop()
16186 
    oprot.writeStructEnd()
16187 
 
16188 
  def validate(self):
16189 
    return
16190 
 
16191 
 
16192 
  def __repr__(self):
16193 
    L = ['%s=%r' % (key, value)
16194 
      for key, value in self.__dict__.iteritems()]
16195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16196 
 
16197 
  def __eq__(self, other):
16198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16199 
 
16200 
  def __ne__(self, other):
16201 
    return not (self == other)
16202 
 
16203 
class getItemForSource_result:
16204 
  """
16205 
  Attributes:
16206 
   - success
16207 
   - cex
16208 
  """
16209 
 
16210 
  thrift_spec = (
16211 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16212 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16213 
  )
16214 
 
16215 
  def __init__(self, success=None, cex=None,):
16216 
    self.success = success
16217 
    self.cex = cex
16218 
 
16219 
  def read(self, iprot):
16220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16222 
      return
16223 
    iprot.readStructBegin()
16224 
    while True:
16225 
      (fname, ftype, fid) = iprot.readFieldBegin()
16226 
      if ftype == TType.STOP:
16227 
        break
16228 
      if fid == 0:
16229 
        if ftype == TType.STRUCT:
16230 
          self.success = Item()
16231 
          self.success.read(iprot)
16232 
        else:
16233 
          iprot.skip(ftype)
16234 
      elif fid == 1:
16235 
        if ftype == TType.STRUCT:
16236 
          self.cex = CatalogServiceException()
16237 
          self.cex.read(iprot)
16238 
        else:
16239 
          iprot.skip(ftype)
16240 
      else:
16241 
        iprot.skip(ftype)
16242 
      iprot.readFieldEnd()
16243 
    iprot.readStructEnd()
16244 
 
16245 
  def write(self, oprot):
16246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16248 
      return
16249 
    oprot.writeStructBegin('getItemForSource_result')
16250 
    if self.success is not None:
16251 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16252 
      self.success.write(oprot)
16253 
      oprot.writeFieldEnd()
16254 
    if self.cex is not None:
16255 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16256 
      self.cex.write(oprot)
16257 
      oprot.writeFieldEnd()
16258 
    oprot.writeFieldStop()
16259 
    oprot.writeStructEnd()
16260 
 
16261 
  def validate(self):
16262 
    return
16263 
 
16264 
 
16265 
  def __repr__(self):
16266 
    L = ['%s=%r' % (key, value)
16267 
      for key, value in self.__dict__.iteritems()]
16268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16269 
 
16270 
  def __eq__(self, other):
16271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16272 
 
16273 
  def __ne__(self, other):
16274 
    return not (self == other)
16275 
 
16276 
class searchItemsInRange_args:
16277 
  """
16278 
  Attributes:
16279 
   - searchTerms
16280 
   - offset
16281 
   - limit
16282 
  """
16283 
 
16284 
  thrift_spec = (
16285 
    None, # 0
16286 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16287 
    (2, TType.I64, 'offset', None, None, ), # 2
16288 
    (3, TType.I64, 'limit', None, None, ), # 3
16289 
  )
16290 
 
16291 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16292 
    self.searchTerms = searchTerms
16293 
    self.offset = offset
16294 
    self.limit = limit
16295 
 
16296 
  def read(self, iprot):
16297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16299 
      return
16300 
    iprot.readStructBegin()
16301 
    while True:
16302 
      (fname, ftype, fid) = iprot.readFieldBegin()
16303 
      if ftype == TType.STOP:
16304 
        break
16305 
      if fid == 1:
16306 
        if ftype == TType.LIST:
16307 
          self.searchTerms = []
9155 kshitij.so 16308 
          (_etype328, _size325) = iprot.readListBegin()
16309 
          for _i329 in xrange(_size325):
16310 
            _elem330 = iprot.readString();
16311 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16312 
          iprot.readListEnd()
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      elif fid == 2:
16316 
        if ftype == TType.I64:
16317 
          self.offset = iprot.readI64();
16318 
        else:
16319 
          iprot.skip(ftype)
16320 
      elif fid == 3:
16321 
        if ftype == TType.I64:
16322 
          self.limit = iprot.readI64();
16323 
        else:
16324 
          iprot.skip(ftype)
16325 
      else:
16326 
        iprot.skip(ftype)
16327 
      iprot.readFieldEnd()
16328 
    iprot.readStructEnd()
16329 
 
16330 
  def write(self, oprot):
16331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16333 
      return
16334 
    oprot.writeStructBegin('searchItemsInRange_args')
16335 
    if self.searchTerms is not None:
16336 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16337 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16338 
      for iter331 in self.searchTerms:
16339 
        oprot.writeString(iter331)
5944 mandeep.dh 16340 
      oprot.writeListEnd()
16341 
      oprot.writeFieldEnd()
16342 
    if self.offset is not None:
16343 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16344 
      oprot.writeI64(self.offset)
16345 
      oprot.writeFieldEnd()
16346 
    if self.limit is not None:
16347 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16348 
      oprot.writeI64(self.limit)
16349 
      oprot.writeFieldEnd()
16350 
    oprot.writeFieldStop()
16351 
    oprot.writeStructEnd()
16352 
 
16353 
  def validate(self):
16354 
    return
16355 
 
16356 
 
16357 
  def __repr__(self):
16358 
    L = ['%s=%r' % (key, value)
16359 
      for key, value in self.__dict__.iteritems()]
16360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16361 
 
16362 
  def __eq__(self, other):
16363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16364 
 
16365 
  def __ne__(self, other):
16366 
    return not (self == other)
16367 
 
16368 
class searchItemsInRange_result:
16369 
  """
16370 
  Attributes:
16371 
   - success
16372 
  """
16373 
 
16374 
  thrift_spec = (
16375 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16376 
  )
16377 
 
16378 
  def __init__(self, success=None,):
16379 
    self.success = success
16380 
 
16381 
  def read(self, iprot):
16382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16384 
      return
16385 
    iprot.readStructBegin()
16386 
    while True:
16387 
      (fname, ftype, fid) = iprot.readFieldBegin()
16388 
      if ftype == TType.STOP:
16389 
        break
16390 
      if fid == 0:
16391 
        if ftype == TType.LIST:
16392 
          self.success = []
9155 kshitij.so 16393 
          (_etype335, _size332) = iprot.readListBegin()
16394 
          for _i336 in xrange(_size332):
16395 
            _elem337 = Item()
16396 
            _elem337.read(iprot)
16397 
            self.success.append(_elem337)
5944 mandeep.dh 16398 
          iprot.readListEnd()
16399 
        else:
16400 
          iprot.skip(ftype)
16401 
      else:
16402 
        iprot.skip(ftype)
16403 
      iprot.readFieldEnd()
16404 
    iprot.readStructEnd()
16405 
 
16406 
  def write(self, oprot):
16407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16409 
      return
16410 
    oprot.writeStructBegin('searchItemsInRange_result')
16411 
    if self.success is not None:
16412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16414 
      for iter338 in self.success:
16415 
        iter338.write(oprot)
5944 mandeep.dh 16416 
      oprot.writeListEnd()
16417 
      oprot.writeFieldEnd()
16418 
    oprot.writeFieldStop()
16419 
    oprot.writeStructEnd()
16420 
 
16421 
  def validate(self):
16422 
    return
16423 
 
16424 
 
16425 
  def __repr__(self):
16426 
    L = ['%s=%r' % (key, value)
16427 
      for key, value in self.__dict__.iteritems()]
16428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16429 
 
16430 
  def __eq__(self, other):
16431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16432 
 
16433 
  def __ne__(self, other):
16434 
    return not (self == other)
16435 
 
16436 
class getSearchResultCount_args:
16437 
  """
16438 
  Attributes:
16439 
   - searchTerms
16440 
  """
16441 
 
16442 
  thrift_spec = (
16443 
    None, # 0
16444 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16445 
  )
16446 
 
16447 
  def __init__(self, searchTerms=None,):
16448 
    self.searchTerms = searchTerms
16449 
 
16450 
  def read(self, iprot):
16451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16453 
      return
16454 
    iprot.readStructBegin()
16455 
    while True:
16456 
      (fname, ftype, fid) = iprot.readFieldBegin()
16457 
      if ftype == TType.STOP:
16458 
        break
16459 
      if fid == 1:
16460 
        if ftype == TType.LIST:
16461 
          self.searchTerms = []
9155 kshitij.so 16462 
          (_etype342, _size339) = iprot.readListBegin()
16463 
          for _i343 in xrange(_size339):
16464 
            _elem344 = iprot.readString();
16465 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 16466 
          iprot.readListEnd()
16467 
        else:
16468 
          iprot.skip(ftype)
16469 
      else:
16470 
        iprot.skip(ftype)
16471 
      iprot.readFieldEnd()
16472 
    iprot.readStructEnd()
16473 
 
16474 
  def write(self, oprot):
16475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16477 
      return
16478 
    oprot.writeStructBegin('getSearchResultCount_args')
16479 
    if self.searchTerms is not None:
16480 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16481 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16482 
      for iter345 in self.searchTerms:
16483 
        oprot.writeString(iter345)
5944 mandeep.dh 16484 
      oprot.writeListEnd()
16485 
      oprot.writeFieldEnd()
16486 
    oprot.writeFieldStop()
16487 
    oprot.writeStructEnd()
16488 
 
16489 
  def validate(self):
16490 
    return
16491 
 
16492 
 
16493 
  def __repr__(self):
16494 
    L = ['%s=%r' % (key, value)
16495 
      for key, value in self.__dict__.iteritems()]
16496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16497 
 
16498 
  def __eq__(self, other):
16499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16500 
 
16501 
  def __ne__(self, other):
16502 
    return not (self == other)
16503 
 
16504 
class getSearchResultCount_result:
16505 
  """
16506 
  Attributes:
16507 
   - success
16508 
  """
16509 
 
16510 
  thrift_spec = (
16511 
    (0, TType.I32, 'success', None, None, ), # 0
16512 
  )
16513 
 
16514 
  def __init__(self, success=None,):
16515 
    self.success = success
16516 
 
16517 
  def read(self, iprot):
16518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16520 
      return
16521 
    iprot.readStructBegin()
16522 
    while True:
16523 
      (fname, ftype, fid) = iprot.readFieldBegin()
16524 
      if ftype == TType.STOP:
16525 
        break
16526 
      if fid == 0:
16527 
        if ftype == TType.I32:
16528 
          self.success = iprot.readI32();
16529 
        else:
16530 
          iprot.skip(ftype)
16531 
      else:
16532 
        iprot.skip(ftype)
16533 
      iprot.readFieldEnd()
16534 
    iprot.readStructEnd()
16535 
 
16536 
  def write(self, oprot):
16537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16539 
      return
16540 
    oprot.writeStructBegin('getSearchResultCount_result')
16541 
    if self.success is not None:
16542 
      oprot.writeFieldBegin('success', TType.I32, 0)
16543 
      oprot.writeI32(self.success)
16544 
      oprot.writeFieldEnd()
16545 
    oprot.writeFieldStop()
16546 
    oprot.writeStructEnd()
16547 
 
16548 
  def validate(self):
16549 
    return
16550 
 
16551 
 
16552 
  def __repr__(self):
16553 
    L = ['%s=%r' % (key, value)
16554 
      for key, value in self.__dict__.iteritems()]
16555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16556 
 
16557 
  def __eq__(self, other):
16558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16559 
 
16560 
  def __ne__(self, other):
16561 
    return not (self == other)
16562 
 
16563 
class getProductNotifications_args:
16564 
  """
16565 
  Attributes:
16566 
   - startDateTime
16567 
  """
16568 
 
16569 
  thrift_spec = (
16570 
    None, # 0
16571 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16572 
  )
16573 
 
16574 
  def __init__(self, startDateTime=None,):
16575 
    self.startDateTime = startDateTime
16576 
 
16577 
  def read(self, iprot):
16578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16580 
      return
16581 
    iprot.readStructBegin()
16582 
    while True:
16583 
      (fname, ftype, fid) = iprot.readFieldBegin()
16584 
      if ftype == TType.STOP:
16585 
        break
16586 
      if fid == 1:
16587 
        if ftype == TType.I64:
16588 
          self.startDateTime = iprot.readI64();
16589 
        else:
16590 
          iprot.skip(ftype)
16591 
      else:
16592 
        iprot.skip(ftype)
16593 
      iprot.readFieldEnd()
16594 
    iprot.readStructEnd()
16595 
 
16596 
  def write(self, oprot):
16597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16599 
      return
16600 
    oprot.writeStructBegin('getProductNotifications_args')
16601 
    if self.startDateTime is not None:
16602 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16603 
      oprot.writeI64(self.startDateTime)
16604 
      oprot.writeFieldEnd()
16605 
    oprot.writeFieldStop()
16606 
    oprot.writeStructEnd()
16607 
 
16608 
  def validate(self):
16609 
    return
16610 
 
16611 
 
16612 
  def __repr__(self):
16613 
    L = ['%s=%r' % (key, value)
16614 
      for key, value in self.__dict__.iteritems()]
16615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16616 
 
16617 
  def __eq__(self, other):
16618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16619 
 
16620 
  def __ne__(self, other):
16621 
    return not (self == other)
16622 
 
16623 
class getProductNotifications_result:
16624 
  """
16625 
  Attributes:
16626 
   - success
16627 
  """
16628 
 
16629 
  thrift_spec = (
16630 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16631 
  )
16632 
 
16633 
  def __init__(self, success=None,):
16634 
    self.success = success
16635 
 
16636 
  def read(self, iprot):
16637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16639 
      return
16640 
    iprot.readStructBegin()
16641 
    while True:
16642 
      (fname, ftype, fid) = iprot.readFieldBegin()
16643 
      if ftype == TType.STOP:
16644 
        break
16645 
      if fid == 0:
16646 
        if ftype == TType.LIST:
16647 
          self.success = []
9155 kshitij.so 16648 
          (_etype349, _size346) = iprot.readListBegin()
16649 
          for _i350 in xrange(_size346):
16650 
            _elem351 = ProductNotificationRequest()
16651 
            _elem351.read(iprot)
16652 
            self.success.append(_elem351)
5944 mandeep.dh 16653 
          iprot.readListEnd()
16654 
        else:
16655 
          iprot.skip(ftype)
16656 
      else:
16657 
        iprot.skip(ftype)
16658 
      iprot.readFieldEnd()
16659 
    iprot.readStructEnd()
16660 
 
16661 
  def write(self, oprot):
16662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16664 
      return
16665 
    oprot.writeStructBegin('getProductNotifications_result')
16666 
    if self.success is not None:
16667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16669 
      for iter352 in self.success:
16670 
        iter352.write(oprot)
5944 mandeep.dh 16671 
      oprot.writeListEnd()
16672 
      oprot.writeFieldEnd()
16673 
    oprot.writeFieldStop()
16674 
    oprot.writeStructEnd()
16675 
 
16676 
  def validate(self):
16677 
    return
16678 
 
16679 
 
16680 
  def __repr__(self):
16681 
    L = ['%s=%r' % (key, value)
16682 
      for key, value in self.__dict__.iteritems()]
16683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16684 
 
16685 
  def __eq__(self, other):
16686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16687 
 
16688 
  def __ne__(self, other):
16689 
    return not (self == other)
16690 
 
16691 
class getProductNotificationRequestCount_args:
16692 
  """
16693 
  Attributes:
16694 
   - startDateTime
7897 amar.kumar 16695 
   - categoryId
5944 mandeep.dh 16696 
  """
16697 
 
16698 
  thrift_spec = (
16699 
    None, # 0
16700 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16701 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16702 
  )
16703 
 
7897 amar.kumar 16704 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16705 
    self.startDateTime = startDateTime
7897 amar.kumar 16706 
    self.categoryId = categoryId
5944 mandeep.dh 16707 
 
16708 
  def read(self, iprot):
16709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16711 
      return
16712 
    iprot.readStructBegin()
16713 
    while True:
16714 
      (fname, ftype, fid) = iprot.readFieldBegin()
16715 
      if ftype == TType.STOP:
16716 
        break
16717 
      if fid == 1:
16718 
        if ftype == TType.I64:
16719 
          self.startDateTime = iprot.readI64();
16720 
        else:
16721 
          iprot.skip(ftype)
7897 amar.kumar 16722 
      elif fid == 2:
16723 
        if ftype == TType.I64:
16724 
          self.categoryId = iprot.readI64();
16725 
        else:
16726 
          iprot.skip(ftype)
5944 mandeep.dh 16727 
      else:
16728 
        iprot.skip(ftype)
16729 
      iprot.readFieldEnd()
16730 
    iprot.readStructEnd()
16731 
 
16732 
  def write(self, oprot):
16733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16735 
      return
16736 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16737 
    if self.startDateTime is not None:
16738 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16739 
      oprot.writeI64(self.startDateTime)
16740 
      oprot.writeFieldEnd()
7897 amar.kumar 16741 
    if self.categoryId is not None:
16742 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16743 
      oprot.writeI64(self.categoryId)
16744 
      oprot.writeFieldEnd()
5944 mandeep.dh 16745 
    oprot.writeFieldStop()
16746 
    oprot.writeStructEnd()
16747 
 
16748 
  def validate(self):
16749 
    return
16750 
 
16751 
 
16752 
  def __repr__(self):
16753 
    L = ['%s=%r' % (key, value)
16754 
      for key, value in self.__dict__.iteritems()]
16755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16756 
 
16757 
  def __eq__(self, other):
16758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16759 
 
16760 
  def __ne__(self, other):
16761 
    return not (self == other)
16762 
 
16763 
class getProductNotificationRequestCount_result:
16764 
  """
16765 
  Attributes:
16766 
   - success
16767 
  """
16768 
 
16769 
  thrift_spec = (
16770 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16771 
  )
16772 
 
16773 
  def __init__(self, success=None,):
16774 
    self.success = success
16775 
 
16776 
  def read(self, iprot):
16777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16779 
      return
16780 
    iprot.readStructBegin()
16781 
    while True:
16782 
      (fname, ftype, fid) = iprot.readFieldBegin()
16783 
      if ftype == TType.STOP:
16784 
        break
16785 
      if fid == 0:
16786 
        if ftype == TType.LIST:
16787 
          self.success = []
9155 kshitij.so 16788 
          (_etype356, _size353) = iprot.readListBegin()
16789 
          for _i357 in xrange(_size353):
16790 
            _elem358 = ProductNotificationRequestCount()
16791 
            _elem358.read(iprot)
16792 
            self.success.append(_elem358)
5944 mandeep.dh 16793 
          iprot.readListEnd()
16794 
        else:
16795 
          iprot.skip(ftype)
16796 
      else:
16797 
        iprot.skip(ftype)
16798 
      iprot.readFieldEnd()
16799 
    iprot.readStructEnd()
16800 
 
16801 
  def write(self, oprot):
16802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16804 
      return
16805 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16806 
    if self.success is not None:
16807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16809 
      for iter359 in self.success:
16810 
        iter359.write(oprot)
5944 mandeep.dh 16811 
      oprot.writeListEnd()
16812 
      oprot.writeFieldEnd()
16813 
    oprot.writeFieldStop()
16814 
    oprot.writeStructEnd()
16815 
 
16816 
  def validate(self):
16817 
    return
16818 
 
16819 
 
16820 
  def __repr__(self):
16821 
    L = ['%s=%r' % (key, value)
16822 
      for key, value in self.__dict__.iteritems()]
16823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16824 
 
16825 
  def __eq__(self, other):
16826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16827 
 
16828 
  def __ne__(self, other):
16829 
    return not (self == other)
16830 
 
16831 
class addAuthorizationLog_args:
16832 
  """
16833 
  Attributes:
16834 
   - itemId
16835 
   - username
16836 
   - reason
16837 
  """
16838 
 
16839 
  thrift_spec = (
16840 
    None, # 0
16841 
    (1, TType.I64, 'itemId', None, None, ), # 1
16842 
    (2, TType.STRING, 'username', None, None, ), # 2
16843 
    (3, TType.STRING, 'reason', None, None, ), # 3
16844 
  )
16845 
 
16846 
  def __init__(self, itemId=None, username=None, reason=None,):
16847 
    self.itemId = itemId
16848 
    self.username = username
16849 
    self.reason = reason
16850 
 
16851 
  def read(self, iprot):
16852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16854 
      return
16855 
    iprot.readStructBegin()
16856 
    while True:
16857 
      (fname, ftype, fid) = iprot.readFieldBegin()
16858 
      if ftype == TType.STOP:
16859 
        break
16860 
      if fid == 1:
16861 
        if ftype == TType.I64:
16862 
          self.itemId = iprot.readI64();
16863 
        else:
16864 
          iprot.skip(ftype)
16865 
      elif fid == 2:
16866 
        if ftype == TType.STRING:
16867 
          self.username = iprot.readString();
16868 
        else:
16869 
          iprot.skip(ftype)
16870 
      elif fid == 3:
16871 
        if ftype == TType.STRING:
16872 
          self.reason = iprot.readString();
16873 
        else:
16874 
          iprot.skip(ftype)
16875 
      else:
16876 
        iprot.skip(ftype)
16877 
      iprot.readFieldEnd()
16878 
    iprot.readStructEnd()
16879 
 
16880 
  def write(self, oprot):
16881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16883 
      return
16884 
    oprot.writeStructBegin('addAuthorizationLog_args')
16885 
    if self.itemId is not None:
16886 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16887 
      oprot.writeI64(self.itemId)
16888 
      oprot.writeFieldEnd()
16889 
    if self.username is not None:
16890 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16891 
      oprot.writeString(self.username)
16892 
      oprot.writeFieldEnd()
16893 
    if self.reason is not None:
16894 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16895 
      oprot.writeString(self.reason)
16896 
      oprot.writeFieldEnd()
16897 
    oprot.writeFieldStop()
16898 
    oprot.writeStructEnd()
16899 
 
16900 
  def validate(self):
16901 
    return
16902 
 
16903 
 
16904 
  def __repr__(self):
16905 
    L = ['%s=%r' % (key, value)
16906 
      for key, value in self.__dict__.iteritems()]
16907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16908 
 
16909 
  def __eq__(self, other):
16910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16911 
 
16912 
  def __ne__(self, other):
16913 
    return not (self == other)
16914 
 
16915 
class addAuthorizationLog_result:
16916 
  """
16917 
  Attributes:
16918 
   - success
16919 
   - cex
16920 
  """
16921 
 
16922 
  thrift_spec = (
16923 
    (0, TType.BOOL, 'success', None, None, ), # 0
16924 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16925 
  )
16926 
 
16927 
  def __init__(self, success=None, cex=None,):
16928 
    self.success = success
16929 
    self.cex = cex
16930 
 
16931 
  def read(self, iprot):
16932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16934 
      return
16935 
    iprot.readStructBegin()
16936 
    while True:
16937 
      (fname, ftype, fid) = iprot.readFieldBegin()
16938 
      if ftype == TType.STOP:
16939 
        break
16940 
      if fid == 0:
16941 
        if ftype == TType.BOOL:
16942 
          self.success = iprot.readBool();
16943 
        else:
16944 
          iprot.skip(ftype)
16945 
      elif fid == 1:
16946 
        if ftype == TType.STRUCT:
16947 
          self.cex = CatalogServiceException()
16948 
          self.cex.read(iprot)
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      else:
16952 
        iprot.skip(ftype)
16953 
      iprot.readFieldEnd()
16954 
    iprot.readStructEnd()
16955 
 
16956 
  def write(self, oprot):
16957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16959 
      return
16960 
    oprot.writeStructBegin('addAuthorizationLog_result')
16961 
    if self.success is not None:
16962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16963 
      oprot.writeBool(self.success)
16964 
      oprot.writeFieldEnd()
16965 
    if self.cex is not None:
16966 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16967 
      self.cex.write(oprot)
16968 
      oprot.writeFieldEnd()
16969 
    oprot.writeFieldStop()
16970 
    oprot.writeStructEnd()
16971 
 
16972 
  def validate(self):
16973 
    return
16974 
 
16975 
 
16976 
  def __repr__(self):
16977 
    L = ['%s=%r' % (key, value)
16978 
      for key, value in self.__dict__.iteritems()]
16979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16980 
 
16981 
  def __eq__(self, other):
16982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16983 
 
16984 
  def __ne__(self, other):
16985 
    return not (self == other)
16986 
 
16987 
class addupdateVoucherForItem_args:
16988 
  """
16989 
  Attributes:
16990 
   - catalog_item_id
16991 
   - voucherType
16992 
   - voucherAmount
16993 
  """
16994 
 
16995 
  thrift_spec = (
16996 
    None, # 0
16997 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16998 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16999 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17000 
  )
17001 
 
17002 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17003 
    self.catalog_item_id = catalog_item_id
17004 
    self.voucherType = voucherType
17005 
    self.voucherAmount = voucherAmount
17006 
 
17007 
  def read(self, iprot):
17008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17010 
      return
17011 
    iprot.readStructBegin()
17012 
    while True:
17013 
      (fname, ftype, fid) = iprot.readFieldBegin()
17014 
      if ftype == TType.STOP:
17015 
        break
17016 
      if fid == 1:
17017 
        if ftype == TType.I64:
17018 
          self.catalog_item_id = iprot.readI64();
17019 
        else:
17020 
          iprot.skip(ftype)
17021 
      elif fid == 2:
17022 
        if ftype == TType.I64:
17023 
          self.voucherType = iprot.readI64();
17024 
        else:
17025 
          iprot.skip(ftype)
17026 
      elif fid == 3:
17027 
        if ftype == TType.I64:
17028 
          self.voucherAmount = iprot.readI64();
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('addupdateVoucherForItem_args')
17041 
    if self.catalog_item_id is not None:
17042 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17043 
      oprot.writeI64(self.catalog_item_id)
17044 
      oprot.writeFieldEnd()
17045 
    if self.voucherType is not None:
17046 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17047 
      oprot.writeI64(self.voucherType)
17048 
      oprot.writeFieldEnd()
17049 
    if self.voucherAmount is not None:
17050 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17051 
      oprot.writeI64(self.voucherAmount)
17052 
      oprot.writeFieldEnd()
17053 
    oprot.writeFieldStop()
17054 
    oprot.writeStructEnd()
17055 
 
17056 
  def validate(self):
17057 
    return
17058 
 
17059 
 
17060 
  def __repr__(self):
17061 
    L = ['%s=%r' % (key, value)
17062 
      for key, value in self.__dict__.iteritems()]
17063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17064 
 
17065 
  def __eq__(self, other):
17066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17067 
 
17068 
  def __ne__(self, other):
17069 
    return not (self == other)
17070 
 
17071 
class addupdateVoucherForItem_result:
17072 
  """
17073 
  Attributes:
17074 
   - success
17075 
   - cex
17076 
  """
17077 
 
17078 
  thrift_spec = (
17079 
    (0, TType.BOOL, 'success', None, None, ), # 0
17080 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17081 
  )
17082 
 
17083 
  def __init__(self, success=None, cex=None,):
17084 
    self.success = success
17085 
    self.cex = cex
17086 
 
17087 
  def read(self, iprot):
17088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17090 
      return
17091 
    iprot.readStructBegin()
17092 
    while True:
17093 
      (fname, ftype, fid) = iprot.readFieldBegin()
17094 
      if ftype == TType.STOP:
17095 
        break
17096 
      if fid == 0:
17097 
        if ftype == TType.BOOL:
17098 
          self.success = iprot.readBool();
17099 
        else:
17100 
          iprot.skip(ftype)
17101 
      elif fid == 1:
17102 
        if ftype == TType.STRUCT:
17103 
          self.cex = CatalogServiceException()
17104 
          self.cex.read(iprot)
17105 
        else:
17106 
          iprot.skip(ftype)
17107 
      else:
17108 
        iprot.skip(ftype)
17109 
      iprot.readFieldEnd()
17110 
    iprot.readStructEnd()
17111 
 
17112 
  def write(self, oprot):
17113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17115 
      return
17116 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17117 
    if self.success is not None:
17118 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17119 
      oprot.writeBool(self.success)
17120 
      oprot.writeFieldEnd()
17121 
    if self.cex is not None:
17122 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17123 
      self.cex.write(oprot)
17124 
      oprot.writeFieldEnd()
17125 
    oprot.writeFieldStop()
17126 
    oprot.writeStructEnd()
17127 
 
17128 
  def validate(self):
17129 
    return
17130 
 
17131 
 
17132 
  def __repr__(self):
17133 
    L = ['%s=%r' % (key, value)
17134 
      for key, value in self.__dict__.iteritems()]
17135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17136 
 
17137 
  def __eq__(self, other):
17138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17139 
 
17140 
  def __ne__(self, other):
17141 
    return not (self == other)
17142 
 
17143 
class deleteVoucherForItem_args:
17144 
  """
17145 
  Attributes:
17146 
   - catalog_item_id
17147 
   - voucherType
17148 
  """
17149 
 
17150 
  thrift_spec = (
17151 
    None, # 0
17152 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17153 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17154 
  )
17155 
 
17156 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17157 
    self.catalog_item_id = catalog_item_id
17158 
    self.voucherType = voucherType
17159 
 
17160 
  def read(self, iprot):
17161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17163 
      return
17164 
    iprot.readStructBegin()
17165 
    while True:
17166 
      (fname, ftype, fid) = iprot.readFieldBegin()
17167 
      if ftype == TType.STOP:
17168 
        break
17169 
      if fid == 1:
17170 
        if ftype == TType.I64:
17171 
          self.catalog_item_id = iprot.readI64();
17172 
        else:
17173 
          iprot.skip(ftype)
17174 
      elif fid == 2:
17175 
        if ftype == TType.I64:
17176 
          self.voucherType = iprot.readI64();
17177 
        else:
17178 
          iprot.skip(ftype)
17179 
      else:
17180 
        iprot.skip(ftype)
17181 
      iprot.readFieldEnd()
17182 
    iprot.readStructEnd()
17183 
 
17184 
  def write(self, oprot):
17185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17187 
      return
17188 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17189 
    if self.catalog_item_id is not None:
17190 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17191 
      oprot.writeI64(self.catalog_item_id)
17192 
      oprot.writeFieldEnd()
17193 
    if self.voucherType is not None:
17194 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17195 
      oprot.writeI64(self.voucherType)
17196 
      oprot.writeFieldEnd()
17197 
    oprot.writeFieldStop()
17198 
    oprot.writeStructEnd()
17199 
 
17200 
  def validate(self):
17201 
    return
17202 
 
17203 
 
17204 
  def __repr__(self):
17205 
    L = ['%s=%r' % (key, value)
17206 
      for key, value in self.__dict__.iteritems()]
17207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17208 
 
17209 
  def __eq__(self, other):
17210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17211 
 
17212 
  def __ne__(self, other):
17213 
    return not (self == other)
17214 
 
17215 
class deleteVoucherForItem_result:
17216 
  """
17217 
  Attributes:
17218 
   - success
17219 
   - cex
17220 
  """
17221 
 
17222 
  thrift_spec = (
17223 
    (0, TType.BOOL, 'success', None, None, ), # 0
17224 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17225 
  )
17226 
 
17227 
  def __init__(self, success=None, cex=None,):
17228 
    self.success = success
17229 
    self.cex = cex
17230 
 
17231 
  def read(self, iprot):
17232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17234 
      return
17235 
    iprot.readStructBegin()
17236 
    while True:
17237 
      (fname, ftype, fid) = iprot.readFieldBegin()
17238 
      if ftype == TType.STOP:
17239 
        break
17240 
      if fid == 0:
17241 
        if ftype == TType.BOOL:
17242 
          self.success = iprot.readBool();
17243 
        else:
17244 
          iprot.skip(ftype)
17245 
      elif fid == 1:
17246 
        if ftype == TType.STRUCT:
17247 
          self.cex = CatalogServiceException()
17248 
          self.cex.read(iprot)
17249 
        else:
17250 
          iprot.skip(ftype)
17251 
      else:
17252 
        iprot.skip(ftype)
17253 
      iprot.readFieldEnd()
17254 
    iprot.readStructEnd()
17255 
 
17256 
  def write(self, oprot):
17257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17259 
      return
17260 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17261 
    if self.success is not None:
17262 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17263 
      oprot.writeBool(self.success)
17264 
      oprot.writeFieldEnd()
17265 
    if self.cex is not None:
17266 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17267 
      self.cex.write(oprot)
17268 
      oprot.writeFieldEnd()
17269 
    oprot.writeFieldStop()
17270 
    oprot.writeStructEnd()
17271 
 
17272 
  def validate(self):
17273 
    return
17274 
 
17275 
 
17276 
  def __repr__(self):
17277 
    L = ['%s=%r' % (key, value)
17278 
      for key, value in self.__dict__.iteritems()]
17279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17280 
 
17281 
  def __eq__(self, other):
17282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17283 
 
17284 
  def __ne__(self, other):
17285 
    return not (self == other)
17286 
 
17287 
class getVoucherAmount_args:
17288 
  """
17289 
  Attributes:
17290 
   - itemId
17291 
   - voucherType
17292 
  """
17293 
 
17294 
  thrift_spec = (
17295 
    None, # 0
17296 
    (1, TType.I64, 'itemId', None, None, ), # 1
17297 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17298 
  )
17299 
 
17300 
  def __init__(self, itemId=None, voucherType=None,):
17301 
    self.itemId = itemId
17302 
    self.voucherType = voucherType
17303 
 
17304 
  def read(self, iprot):
17305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17307 
      return
17308 
    iprot.readStructBegin()
17309 
    while True:
17310 
      (fname, ftype, fid) = iprot.readFieldBegin()
17311 
      if ftype == TType.STOP:
17312 
        break
17313 
      if fid == 1:
17314 
        if ftype == TType.I64:
17315 
          self.itemId = iprot.readI64();
17316 
        else:
17317 
          iprot.skip(ftype)
17318 
      elif fid == 2:
17319 
        if ftype == TType.I64:
17320 
          self.voucherType = iprot.readI64();
17321 
        else:
17322 
          iprot.skip(ftype)
17323 
      else:
17324 
        iprot.skip(ftype)
17325 
      iprot.readFieldEnd()
17326 
    iprot.readStructEnd()
17327 
 
17328 
  def write(self, oprot):
17329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17331 
      return
17332 
    oprot.writeStructBegin('getVoucherAmount_args')
17333 
    if self.itemId is not None:
17334 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17335 
      oprot.writeI64(self.itemId)
17336 
      oprot.writeFieldEnd()
17337 
    if self.voucherType is not None:
17338 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17339 
      oprot.writeI64(self.voucherType)
17340 
      oprot.writeFieldEnd()
17341 
    oprot.writeFieldStop()
17342 
    oprot.writeStructEnd()
17343 
 
17344 
  def validate(self):
17345 
    return
17346 
 
17347 
 
17348 
  def __repr__(self):
17349 
    L = ['%s=%r' % (key, value)
17350 
      for key, value in self.__dict__.iteritems()]
17351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17352 
 
17353 
  def __eq__(self, other):
17354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17355 
 
17356 
  def __ne__(self, other):
17357 
    return not (self == other)
17358 
 
17359 
class getVoucherAmount_result:
17360 
  """
17361 
  Attributes:
17362 
   - success
17363 
  """
17364 
 
17365 
  thrift_spec = (
17366 
    (0, TType.I64, 'success', None, None, ), # 0
17367 
  )
17368 
 
17369 
  def __init__(self, success=None,):
17370 
    self.success = success
17371 
 
17372 
  def read(self, iprot):
17373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17375 
      return
17376 
    iprot.readStructBegin()
17377 
    while True:
17378 
      (fname, ftype, fid) = iprot.readFieldBegin()
17379 
      if ftype == TType.STOP:
17380 
        break
17381 
      if fid == 0:
17382 
        if ftype == TType.I64:
17383 
          self.success = iprot.readI64();
17384 
        else:
17385 
          iprot.skip(ftype)
17386 
      else:
17387 
        iprot.skip(ftype)
17388 
      iprot.readFieldEnd()
17389 
    iprot.readStructEnd()
17390 
 
17391 
  def write(self, oprot):
17392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17394 
      return
17395 
    oprot.writeStructBegin('getVoucherAmount_result')
17396 
    if self.success is not None:
17397 
      oprot.writeFieldBegin('success', TType.I64, 0)
17398 
      oprot.writeI64(self.success)
17399 
      oprot.writeFieldEnd()
17400 
    oprot.writeFieldStop()
17401 
    oprot.writeStructEnd()
17402 
 
17403 
  def validate(self):
17404 
    return
17405 
 
17406 
 
17407 
  def __repr__(self):
17408 
    L = ['%s=%r' % (key, value)
17409 
      for key, value in self.__dict__.iteritems()]
17410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17411 
 
17412 
  def __eq__(self, other):
17413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17414 
 
17415 
  def __ne__(self, other):
17416 
    return not (self == other)
17417 
 
17418 
class getAllItemVouchers_args:
17419 
  """
17420 
  Attributes:
17421 
   - itemId
17422 
  """
17423 
 
17424 
  thrift_spec = (
17425 
    None, # 0
17426 
    (1, TType.I64, 'itemId', None, None, ), # 1
17427 
  )
17428 
 
17429 
  def __init__(self, itemId=None,):
17430 
    self.itemId = itemId
17431 
 
17432 
  def read(self, iprot):
17433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17435 
      return
17436 
    iprot.readStructBegin()
17437 
    while True:
17438 
      (fname, ftype, fid) = iprot.readFieldBegin()
17439 
      if ftype == TType.STOP:
17440 
        break
17441 
      if fid == 1:
17442 
        if ftype == TType.I64:
17443 
          self.itemId = iprot.readI64();
17444 
        else:
17445 
          iprot.skip(ftype)
17446 
      else:
17447 
        iprot.skip(ftype)
17448 
      iprot.readFieldEnd()
17449 
    iprot.readStructEnd()
17450 
 
17451 
  def write(self, oprot):
17452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17454 
      return
17455 
    oprot.writeStructBegin('getAllItemVouchers_args')
17456 
    if self.itemId is not None:
17457 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17458 
      oprot.writeI64(self.itemId)
17459 
      oprot.writeFieldEnd()
17460 
    oprot.writeFieldStop()
17461 
    oprot.writeStructEnd()
17462 
 
17463 
  def validate(self):
17464 
    return
17465 
 
17466 
 
17467 
  def __repr__(self):
17468 
    L = ['%s=%r' % (key, value)
17469 
      for key, value in self.__dict__.iteritems()]
17470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17471 
 
17472 
  def __eq__(self, other):
17473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17474 
 
17475 
  def __ne__(self, other):
17476 
    return not (self == other)
17477 
 
17478 
class getAllItemVouchers_result:
17479 
  """
17480 
  Attributes:
17481 
   - success
17482 
  """
17483 
 
17484 
  thrift_spec = (
17485 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17486 
  )
17487 
 
17488 
  def __init__(self, success=None,):
17489 
    self.success = success
17490 
 
17491 
  def read(self, iprot):
17492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17494 
      return
17495 
    iprot.readStructBegin()
17496 
    while True:
17497 
      (fname, ftype, fid) = iprot.readFieldBegin()
17498 
      if ftype == TType.STOP:
17499 
        break
17500 
      if fid == 0:
17501 
        if ftype == TType.LIST:
17502 
          self.success = []
9155 kshitij.so 17503 
          (_etype363, _size360) = iprot.readListBegin()
17504 
          for _i364 in xrange(_size360):
17505 
            _elem365 = VoucherItemMapping()
17506 
            _elem365.read(iprot)
17507 
            self.success.append(_elem365)
5944 mandeep.dh 17508 
          iprot.readListEnd()
17509 
        else:
17510 
          iprot.skip(ftype)
17511 
      else:
17512 
        iprot.skip(ftype)
17513 
      iprot.readFieldEnd()
17514 
    iprot.readStructEnd()
17515 
 
17516 
  def write(self, oprot):
17517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17519 
      return
17520 
    oprot.writeStructBegin('getAllItemVouchers_result')
17521 
    if self.success is not None:
17522 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17523 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17524 
      for iter366 in self.success:
17525 
        iter366.write(oprot)
5944 mandeep.dh 17526 
      oprot.writeListEnd()
17527 
      oprot.writeFieldEnd()
17528 
    oprot.writeFieldStop()
17529 
    oprot.writeStructEnd()
17530 
 
17531 
  def validate(self):
17532 
    return
17533 
 
17534 
 
17535 
  def __repr__(self):
17536 
    L = ['%s=%r' % (key, value)
17537 
      for key, value in self.__dict__.iteritems()]
17538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17539 
 
17540 
  def __eq__(self, other):
17541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17542 
 
17543 
  def __ne__(self, other):
17544 
    return not (self == other)
17545 
 
17546 
class isValidCatalogItemId_args:
17547 
  """
17548 
  Attributes:
17549 
   - catalog_item_id
17550 
  """
17551 
 
17552 
  thrift_spec = (
17553 
    None, # 0
17554 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17555 
  )
17556 
 
17557 
  def __init__(self, catalog_item_id=None,):
17558 
    self.catalog_item_id = catalog_item_id
17559 
 
17560 
  def read(self, iprot):
17561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17563 
      return
17564 
    iprot.readStructBegin()
17565 
    while True:
17566 
      (fname, ftype, fid) = iprot.readFieldBegin()
17567 
      if ftype == TType.STOP:
17568 
        break
17569 
      if fid == 1:
17570 
        if ftype == TType.I64:
17571 
          self.catalog_item_id = iprot.readI64();
17572 
        else:
17573 
          iprot.skip(ftype)
17574 
      else:
17575 
        iprot.skip(ftype)
17576 
      iprot.readFieldEnd()
17577 
    iprot.readStructEnd()
17578 
 
17579 
  def write(self, oprot):
17580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17582 
      return
17583 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17584 
    if self.catalog_item_id is not None:
17585 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17586 
      oprot.writeI64(self.catalog_item_id)
17587 
      oprot.writeFieldEnd()
17588 
    oprot.writeFieldStop()
17589 
    oprot.writeStructEnd()
17590 
 
17591 
  def validate(self):
17592 
    return
17593 
 
17594 
 
17595 
  def __repr__(self):
17596 
    L = ['%s=%r' % (key, value)
17597 
      for key, value in self.__dict__.iteritems()]
17598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17599 
 
17600 
  def __eq__(self, other):
17601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17602 
 
17603 
  def __ne__(self, other):
17604 
    return not (self == other)
17605 
 
17606 
class isValidCatalogItemId_result:
17607 
  """
17608 
  Attributes:
17609 
   - success
17610 
  """
17611 
 
17612 
  thrift_spec = (
17613 
    (0, TType.BOOL, 'success', None, None, ), # 0
17614 
  )
17615 
 
17616 
  def __init__(self, success=None,):
17617 
    self.success = success
17618 
 
17619 
  def read(self, iprot):
17620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17622 
      return
17623 
    iprot.readStructBegin()
17624 
    while True:
17625 
      (fname, ftype, fid) = iprot.readFieldBegin()
17626 
      if ftype == TType.STOP:
17627 
        break
17628 
      if fid == 0:
17629 
        if ftype == TType.BOOL:
17630 
          self.success = iprot.readBool();
17631 
        else:
17632 
          iprot.skip(ftype)
17633 
      else:
17634 
        iprot.skip(ftype)
17635 
      iprot.readFieldEnd()
17636 
    iprot.readStructEnd()
17637 
 
17638 
  def write(self, oprot):
17639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17641 
      return
17642 
    oprot.writeStructBegin('isValidCatalogItemId_result')
17643 
    if self.success is not None:
17644 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17645 
      oprot.writeBool(self.success)
17646 
      oprot.writeFieldEnd()
17647 
    oprot.writeFieldStop()
17648 
    oprot.writeStructEnd()
17649 
 
17650 
  def validate(self):
17651 
    return
17652 
 
17653 
 
17654 
  def __repr__(self):
17655 
    L = ['%s=%r' % (key, value)
17656 
      for key, value in self.__dict__.iteritems()]
17657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17658 
 
17659 
  def __eq__(self, other):
17660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17661 
 
17662 
  def __ne__(self, other):
17663 
    return not (self == other)
6039 amit.gupta 17664 
 
17665 
class getVatPercentageForItem_args:
17666 
  """
17667 
  Attributes:
17668 
   - itemId
7330 amit.gupta 17669 
   - stateId
6039 amit.gupta 17670 
   - price
17671 
  """
17672 
 
17673 
  thrift_spec = (
17674 
    None, # 0
17675 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17676 
    (2, TType.I64, 'stateId', None, None, ), # 2
17677 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17678 
  )
17679 
 
7330 amit.gupta 17680 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17681 
    self.itemId = itemId
7330 amit.gupta 17682 
    self.stateId = stateId
6039 amit.gupta 17683 
    self.price = price
17684 
 
17685 
  def read(self, iprot):
17686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17688 
      return
17689 
    iprot.readStructBegin()
17690 
    while True:
17691 
      (fname, ftype, fid) = iprot.readFieldBegin()
17692 
      if ftype == TType.STOP:
17693 
        break
17694 
      if fid == 1:
17695 
        if ftype == TType.I64:
17696 
          self.itemId = iprot.readI64();
17697 
        else:
17698 
          iprot.skip(ftype)
17699 
      elif fid == 2:
7330 amit.gupta 17700 
        if ftype == TType.I64:
17701 
          self.stateId = iprot.readI64();
17702 
        else:
17703 
          iprot.skip(ftype)
17704 
      elif fid == 3:
6039 amit.gupta 17705 
        if ftype == TType.DOUBLE:
17706 
          self.price = iprot.readDouble();
17707 
        else:
17708 
          iprot.skip(ftype)
17709 
      else:
17710 
        iprot.skip(ftype)
17711 
      iprot.readFieldEnd()
17712 
    iprot.readStructEnd()
17713 
 
17714 
  def write(self, oprot):
17715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17717 
      return
17718 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17719 
    if self.itemId is not None:
17720 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17721 
      oprot.writeI64(self.itemId)
17722 
      oprot.writeFieldEnd()
7330 amit.gupta 17723 
    if self.stateId is not None:
17724 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17725 
      oprot.writeI64(self.stateId)
17726 
      oprot.writeFieldEnd()
6039 amit.gupta 17727 
    if self.price is not None:
7330 amit.gupta 17728 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17729 
      oprot.writeDouble(self.price)
17730 
      oprot.writeFieldEnd()
17731 
    oprot.writeFieldStop()
17732 
    oprot.writeStructEnd()
17733 
 
17734 
  def validate(self):
17735 
    return
17736 
 
17737 
 
17738 
  def __repr__(self):
17739 
    L = ['%s=%r' % (key, value)
17740 
      for key, value in self.__dict__.iteritems()]
17741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17742 
 
17743 
  def __eq__(self, other):
17744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17745 
 
17746 
  def __ne__(self, other):
17747 
    return not (self == other)
17748 
 
17749 
class getVatPercentageForItem_result:
17750 
  """
17751 
  Attributes:
17752 
   - success
7340 amit.gupta 17753 
   - cex
6039 amit.gupta 17754 
  """
17755 
 
17756 
  thrift_spec = (
17757 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17758 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17759 
  )
17760 
 
7340 amit.gupta 17761 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17762 
    self.success = success
7340 amit.gupta 17763 
    self.cex = cex
6039 amit.gupta 17764 
 
17765 
  def read(self, iprot):
17766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17768 
      return
17769 
    iprot.readStructBegin()
17770 
    while True:
17771 
      (fname, ftype, fid) = iprot.readFieldBegin()
17772 
      if ftype == TType.STOP:
17773 
        break
17774 
      if fid == 0:
17775 
        if ftype == TType.DOUBLE:
17776 
          self.success = iprot.readDouble();
17777 
        else:
17778 
          iprot.skip(ftype)
7340 amit.gupta 17779 
      elif fid == 1:
17780 
        if ftype == TType.STRUCT:
17781 
          self.cex = CatalogServiceException()
17782 
          self.cex.read(iprot)
17783 
        else:
17784 
          iprot.skip(ftype)
6039 amit.gupta 17785 
      else:
17786 
        iprot.skip(ftype)
17787 
      iprot.readFieldEnd()
17788 
    iprot.readStructEnd()
17789 
 
17790 
  def write(self, oprot):
17791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17793 
      return
17794 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17795 
    if self.success is not None:
17796 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17797 
      oprot.writeDouble(self.success)
17798 
      oprot.writeFieldEnd()
7340 amit.gupta 17799 
    if self.cex is not None:
17800 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17801 
      self.cex.write(oprot)
17802 
      oprot.writeFieldEnd()
6039 amit.gupta 17803 
    oprot.writeFieldStop()
17804 
    oprot.writeStructEnd()
17805 
 
17806 
  def validate(self):
17807 
    return
17808 
 
17809 
 
17810 
  def __repr__(self):
17811 
    L = ['%s=%r' % (key, value)
17812 
      for key, value in self.__dict__.iteritems()]
17813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17814 
 
17815 
  def __eq__(self, other):
17816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17817 
 
17818 
  def __ne__(self, other):
17819 
    return not (self == other)
17820 
 
17821 
class getVatAmountForItem_args:
17822 
  """
17823 
  Attributes:
17824 
   - itemId
17825 
   - price
17826 
  """
17827 
 
17828 
  thrift_spec = (
17829 
    None, # 0
17830 
    (1, TType.I64, 'itemId', None, None, ), # 1
17831 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17832 
  )
17833 
 
17834 
  def __init__(self, itemId=None, price=None,):
17835 
    self.itemId = itemId
17836 
    self.price = price
17837 
 
17838 
  def read(self, iprot):
17839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17841 
      return
17842 
    iprot.readStructBegin()
17843 
    while True:
17844 
      (fname, ftype, fid) = iprot.readFieldBegin()
17845 
      if ftype == TType.STOP:
17846 
        break
17847 
      if fid == 1:
17848 
        if ftype == TType.I64:
17849 
          self.itemId = iprot.readI64();
17850 
        else:
17851 
          iprot.skip(ftype)
17852 
      elif fid == 2:
17853 
        if ftype == TType.DOUBLE:
17854 
          self.price = iprot.readDouble();
17855 
        else:
17856 
          iprot.skip(ftype)
17857 
      else:
17858 
        iprot.skip(ftype)
17859 
      iprot.readFieldEnd()
17860 
    iprot.readStructEnd()
17861 
 
17862 
  def write(self, oprot):
17863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17865 
      return
17866 
    oprot.writeStructBegin('getVatAmountForItem_args')
17867 
    if self.itemId is not None:
17868 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17869 
      oprot.writeI64(self.itemId)
17870 
      oprot.writeFieldEnd()
17871 
    if self.price is not None:
17872 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17873 
      oprot.writeDouble(self.price)
17874 
      oprot.writeFieldEnd()
17875 
    oprot.writeFieldStop()
17876 
    oprot.writeStructEnd()
17877 
 
17878 
  def validate(self):
17879 
    return
17880 
 
17881 
 
17882 
  def __repr__(self):
17883 
    L = ['%s=%r' % (key, value)
17884 
      for key, value in self.__dict__.iteritems()]
17885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17886 
 
17887 
  def __eq__(self, other):
17888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17889 
 
17890 
  def __ne__(self, other):
17891 
    return not (self == other)
17892 
 
17893 
class getVatAmountForItem_result:
17894 
  """
17895 
  Attributes:
17896 
   - success
17897 
  """
17898 
 
17899 
  thrift_spec = (
17900 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17901 
  )
17902 
 
17903 
  def __init__(self, success=None,):
17904 
    self.success = success
17905 
 
17906 
  def read(self, iprot):
17907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17909 
      return
17910 
    iprot.readStructBegin()
17911 
    while True:
17912 
      (fname, ftype, fid) = iprot.readFieldBegin()
17913 
      if ftype == TType.STOP:
17914 
        break
17915 
      if fid == 0:
17916 
        if ftype == TType.DOUBLE:
17917 
          self.success = iprot.readDouble();
17918 
        else:
17919 
          iprot.skip(ftype)
17920 
      else:
17921 
        iprot.skip(ftype)
17922 
      iprot.readFieldEnd()
17923 
    iprot.readStructEnd()
17924 
 
17925 
  def write(self, oprot):
17926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17928 
      return
17929 
    oprot.writeStructBegin('getVatAmountForItem_result')
17930 
    if self.success is not None:
17931 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17932 
      oprot.writeDouble(self.success)
17933 
      oprot.writeFieldEnd()
17934 
    oprot.writeFieldStop()
17935 
    oprot.writeStructEnd()
17936 
 
17937 
  def validate(self):
17938 
    return
17939 
 
17940 
 
17941 
  def __repr__(self):
17942 
    L = ['%s=%r' % (key, value)
17943 
      for key, value in self.__dict__.iteritems()]
17944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17945 
 
17946 
  def __eq__(self, other):
17947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17948 
 
17949 
  def __ne__(self, other):
17950 
    return not (self == other)
6531 vikram.rag 17951 
 
17952 
class getAllIgnoredInventoryUpdateItemsList_args:
17953 
  """
17954 
  Attributes:
17955 
   - offset
17956 
   - limit
17957 
  """
17958 
 
17959 
  thrift_spec = (
17960 
    None, # 0
17961 
    (1, TType.I32, 'offset', None, None, ), # 1
17962 
    (2, TType.I32, 'limit', None, None, ), # 2
17963 
  )
17964 
 
17965 
  def __init__(self, offset=None, limit=None,):
17966 
    self.offset = offset
17967 
    self.limit = limit
17968 
 
17969 
  def read(self, iprot):
17970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17972 
      return
17973 
    iprot.readStructBegin()
17974 
    while True:
17975 
      (fname, ftype, fid) = iprot.readFieldBegin()
17976 
      if ftype == TType.STOP:
17977 
        break
17978 
      if fid == 1:
17979 
        if ftype == TType.I32:
17980 
          self.offset = iprot.readI32();
17981 
        else:
17982 
          iprot.skip(ftype)
17983 
      elif fid == 2:
17984 
        if ftype == TType.I32:
17985 
          self.limit = iprot.readI32();
17986 
        else:
17987 
          iprot.skip(ftype)
17988 
      else:
17989 
        iprot.skip(ftype)
17990 
      iprot.readFieldEnd()
17991 
    iprot.readStructEnd()
17992 
 
17993 
  def write(self, oprot):
17994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17996 
      return
17997 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17998 
    if self.offset is not None:
17999 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18000 
      oprot.writeI32(self.offset)
18001 
      oprot.writeFieldEnd()
18002 
    if self.limit is not None:
18003 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18004 
      oprot.writeI32(self.limit)
18005 
      oprot.writeFieldEnd()
18006 
    oprot.writeFieldStop()
18007 
    oprot.writeStructEnd()
18008 
 
18009 
  def validate(self):
18010 
    return
18011 
 
18012 
 
18013 
  def __repr__(self):
18014 
    L = ['%s=%r' % (key, value)
18015 
      for key, value in self.__dict__.iteritems()]
18016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18017 
 
18018 
  def __eq__(self, other):
18019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18020 
 
18021 
  def __ne__(self, other):
18022 
    return not (self == other)
18023 
 
18024 
class getAllIgnoredInventoryUpdateItemsList_result:
18025 
  """
18026 
  Attributes:
18027 
   - success
18028 
  """
18029 
 
18030 
  thrift_spec = (
18031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18032 
  )
18033 
 
18034 
  def __init__(self, success=None,):
18035 
    self.success = success
18036 
 
18037 
  def read(self, iprot):
18038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18040 
      return
18041 
    iprot.readStructBegin()
18042 
    while True:
18043 
      (fname, ftype, fid) = iprot.readFieldBegin()
18044 
      if ftype == TType.STOP:
18045 
        break
18046 
      if fid == 0:
18047 
        if ftype == TType.LIST:
18048 
          self.success = []
9155 kshitij.so 18049 
          (_etype370, _size367) = iprot.readListBegin()
18050 
          for _i371 in xrange(_size367):
18051 
            _elem372 = Item()
18052 
            _elem372.read(iprot)
18053 
            self.success.append(_elem372)
6531 vikram.rag 18054 
          iprot.readListEnd()
18055 
        else:
18056 
          iprot.skip(ftype)
18057 
      else:
18058 
        iprot.skip(ftype)
18059 
      iprot.readFieldEnd()
18060 
    iprot.readStructEnd()
18061 
 
18062 
  def write(self, oprot):
18063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18065 
      return
18066 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18067 
    if self.success is not None:
18068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18070 
      for iter373 in self.success:
18071 
        iter373.write(oprot)
6531 vikram.rag 18072 
      oprot.writeListEnd()
18073 
      oprot.writeFieldEnd()
18074 
    oprot.writeFieldStop()
18075 
    oprot.writeStructEnd()
18076 
 
18077 
  def validate(self):
18078 
    return
18079 
 
18080 
 
18081 
  def __repr__(self):
18082 
    L = ['%s=%r' % (key, value)
18083 
      for key, value in self.__dict__.iteritems()]
18084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18085 
 
18086 
  def __eq__(self, other):
18087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18088 
 
18089 
  def __ne__(self, other):
18090 
    return not (self == other)
6805 anupam.sin 18091 
 
6821 amar.kumar 18092 
class getAllAliveItems_args:
18093 
 
18094 
  thrift_spec = (
18095 
  )
18096 
 
18097 
  def read(self, iprot):
18098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18100 
      return
18101 
    iprot.readStructBegin()
18102 
    while True:
18103 
      (fname, ftype, fid) = iprot.readFieldBegin()
18104 
      if ftype == TType.STOP:
18105 
        break
18106 
      else:
18107 
        iprot.skip(ftype)
18108 
      iprot.readFieldEnd()
18109 
    iprot.readStructEnd()
18110 
 
18111 
  def write(self, oprot):
18112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18114 
      return
18115 
    oprot.writeStructBegin('getAllAliveItems_args')
18116 
    oprot.writeFieldStop()
18117 
    oprot.writeStructEnd()
18118 
 
18119 
  def validate(self):
18120 
    return
18121 
 
18122 
 
18123 
  def __repr__(self):
18124 
    L = ['%s=%r' % (key, value)
18125 
      for key, value in self.__dict__.iteritems()]
18126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18127 
 
18128 
  def __eq__(self, other):
18129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18130 
 
18131 
  def __ne__(self, other):
18132 
    return not (self == other)
18133 
 
18134 
class getAllAliveItems_result:
18135 
  """
18136 
  Attributes:
18137 
   - success
18138 
  """
18139 
 
18140 
  thrift_spec = (
18141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18142 
  )
18143 
 
18144 
  def __init__(self, success=None,):
18145 
    self.success = success
18146 
 
18147 
  def read(self, iprot):
18148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18150 
      return
18151 
    iprot.readStructBegin()
18152 
    while True:
18153 
      (fname, ftype, fid) = iprot.readFieldBegin()
18154 
      if ftype == TType.STOP:
18155 
        break
18156 
      if fid == 0:
18157 
        if ftype == TType.LIST:
18158 
          self.success = []
9155 kshitij.so 18159 
          (_etype377, _size374) = iprot.readListBegin()
18160 
          for _i378 in xrange(_size374):
18161 
            _elem379 = Item()
18162 
            _elem379.read(iprot)
18163 
            self.success.append(_elem379)
6821 amar.kumar 18164 
          iprot.readListEnd()
18165 
        else:
18166 
          iprot.skip(ftype)
18167 
      else:
18168 
        iprot.skip(ftype)
18169 
      iprot.readFieldEnd()
18170 
    iprot.readStructEnd()
18171 
 
18172 
  def write(self, oprot):
18173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18175 
      return
18176 
    oprot.writeStructBegin('getAllAliveItems_result')
18177 
    if self.success is not None:
18178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18180 
      for iter380 in self.success:
18181 
        iter380.write(oprot)
6821 amar.kumar 18182 
      oprot.writeListEnd()
18183 
      oprot.writeFieldEnd()
18184 
    oprot.writeFieldStop()
18185 
    oprot.writeStructEnd()
18186 
 
18187 
  def validate(self):
18188 
    return
18189 
 
18190 
 
18191 
  def __repr__(self):
18192 
    L = ['%s=%r' % (key, value)
18193 
      for key, value in self.__dict__.iteritems()]
18194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18195 
 
18196 
  def __eq__(self, other):
18197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18198 
 
18199 
  def __ne__(self, other):
18200 
    return not (self == other)
18201 
 
6805 anupam.sin 18202 
class getInsuranceAmount_args:
18203 
  """
18204 
  Attributes:
18205 
   - itemId
6921 anupam.sin 18206 
   - price
6805 anupam.sin 18207 
   - insurerId
18208 
   - quantity
18209 
  """
18210 
 
18211 
  thrift_spec = (
18212 
    None, # 0
18213 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18214 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18215 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18216 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18217 
  )
18218 
 
6921 anupam.sin 18219 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18220 
    self.itemId = itemId
6921 anupam.sin 18221 
    self.price = price
6805 anupam.sin 18222 
    self.insurerId = insurerId
18223 
    self.quantity = quantity
18224 
 
18225 
  def read(self, iprot):
18226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18228 
      return
18229 
    iprot.readStructBegin()
18230 
    while True:
18231 
      (fname, ftype, fid) = iprot.readFieldBegin()
18232 
      if ftype == TType.STOP:
18233 
        break
18234 
      if fid == 1:
18235 
        if ftype == TType.I64:
18236 
          self.itemId = iprot.readI64();
18237 
        else:
18238 
          iprot.skip(ftype)
18239 
      elif fid == 2:
6921 anupam.sin 18240 
        if ftype == TType.DOUBLE:
18241 
          self.price = iprot.readDouble();
18242 
        else:
18243 
          iprot.skip(ftype)
18244 
      elif fid == 3:
6805 anupam.sin 18245 
        if ftype == TType.I64:
18246 
          self.insurerId = iprot.readI64();
18247 
        else:
18248 
          iprot.skip(ftype)
6921 anupam.sin 18249 
      elif fid == 4:
6805 anupam.sin 18250 
        if ftype == TType.I64:
18251 
          self.quantity = iprot.readI64();
18252 
        else:
18253 
          iprot.skip(ftype)
18254 
      else:
18255 
        iprot.skip(ftype)
18256 
      iprot.readFieldEnd()
18257 
    iprot.readStructEnd()
18258 
 
18259 
  def write(self, oprot):
18260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18262 
      return
18263 
    oprot.writeStructBegin('getInsuranceAmount_args')
18264 
    if self.itemId is not None:
18265 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18266 
      oprot.writeI64(self.itemId)
18267 
      oprot.writeFieldEnd()
6921 anupam.sin 18268 
    if self.price is not None:
18269 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18270 
      oprot.writeDouble(self.price)
18271 
      oprot.writeFieldEnd()
6805 anupam.sin 18272 
    if self.insurerId is not None:
6921 anupam.sin 18273 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18274 
      oprot.writeI64(self.insurerId)
18275 
      oprot.writeFieldEnd()
18276 
    if self.quantity is not None:
6921 anupam.sin 18277 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18278 
      oprot.writeI64(self.quantity)
18279 
      oprot.writeFieldEnd()
18280 
    oprot.writeFieldStop()
18281 
    oprot.writeStructEnd()
18282 
 
18283 
  def validate(self):
18284 
    return
18285 
 
18286 
 
18287 
  def __repr__(self):
18288 
    L = ['%s=%r' % (key, value)
18289 
      for key, value in self.__dict__.iteritems()]
18290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18291 
 
18292 
  def __eq__(self, other):
18293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18294 
 
18295 
  def __ne__(self, other):
18296 
    return not (self == other)
18297 
 
18298 
class getInsuranceAmount_result:
18299 
  """
18300 
  Attributes:
18301 
   - success
18302 
  """
18303 
 
18304 
  thrift_spec = (
18305 
    (0, TType.I64, 'success', None, None, ), # 0
18306 
  )
18307 
 
18308 
  def __init__(self, success=None,):
18309 
    self.success = success
18310 
 
18311 
  def read(self, iprot):
18312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18314 
      return
18315 
    iprot.readStructBegin()
18316 
    while True:
18317 
      (fname, ftype, fid) = iprot.readFieldBegin()
18318 
      if ftype == TType.STOP:
18319 
        break
18320 
      if fid == 0:
18321 
        if ftype == TType.I64:
18322 
          self.success = iprot.readI64();
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('getInsuranceAmount_result')
18335 
    if self.success is not None:
18336 
      oprot.writeFieldBegin('success', TType.I64, 0)
18337 
      oprot.writeI64(self.success)
18338 
      oprot.writeFieldEnd()
18339 
    oprot.writeFieldStop()
18340 
    oprot.writeStructEnd()
18341 
 
18342 
  def validate(self):
18343 
    return
18344 
 
18345 
 
18346 
  def __repr__(self):
18347 
    L = ['%s=%r' % (key, value)
18348 
      for key, value in self.__dict__.iteritems()]
18349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18350 
 
18351 
  def __eq__(self, other):
18352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18353 
 
18354 
  def __ne__(self, other):
18355 
    return not (self == other)
18356 
 
18357 
class getInsurer_args:
18358 
  """
18359 
  Attributes:
18360 
   - insurerId
18361 
  """
18362 
 
18363 
  thrift_spec = (
18364 
    None, # 0
18365 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18366 
  )
18367 
 
18368 
  def __init__(self, insurerId=None,):
18369 
    self.insurerId = insurerId
18370 
 
18371 
  def read(self, iprot):
18372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18374 
      return
18375 
    iprot.readStructBegin()
18376 
    while True:
18377 
      (fname, ftype, fid) = iprot.readFieldBegin()
18378 
      if ftype == TType.STOP:
18379 
        break
18380 
      if fid == 1:
18381 
        if ftype == TType.I64:
18382 
          self.insurerId = iprot.readI64();
18383 
        else:
18384 
          iprot.skip(ftype)
18385 
      else:
18386 
        iprot.skip(ftype)
18387 
      iprot.readFieldEnd()
18388 
    iprot.readStructEnd()
18389 
 
18390 
  def write(self, oprot):
18391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18393 
      return
18394 
    oprot.writeStructBegin('getInsurer_args')
18395 
    if self.insurerId is not None:
18396 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18397 
      oprot.writeI64(self.insurerId)
18398 
      oprot.writeFieldEnd()
18399 
    oprot.writeFieldStop()
18400 
    oprot.writeStructEnd()
18401 
 
18402 
  def validate(self):
18403 
    return
18404 
 
18405 
 
18406 
  def __repr__(self):
18407 
    L = ['%s=%r' % (key, value)
18408 
      for key, value in self.__dict__.iteritems()]
18409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18410 
 
18411 
  def __eq__(self, other):
18412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18413 
 
18414 
  def __ne__(self, other):
18415 
    return not (self == other)
18416 
 
18417 
class getInsurer_result:
18418 
  """
18419 
  Attributes:
18420 
   - success
18421 
  """
18422 
 
18423 
  thrift_spec = (
18424 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18425 
  )
18426 
 
18427 
  def __init__(self, success=None,):
18428 
    self.success = success
18429 
 
18430 
  def read(self, iprot):
18431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18433 
      return
18434 
    iprot.readStructBegin()
18435 
    while True:
18436 
      (fname, ftype, fid) = iprot.readFieldBegin()
18437 
      if ftype == TType.STOP:
18438 
        break
18439 
      if fid == 0:
18440 
        if ftype == TType.STRUCT:
18441 
          self.success = Insurer()
18442 
          self.success.read(iprot)
18443 
        else:
18444 
          iprot.skip(ftype)
18445 
      else:
18446 
        iprot.skip(ftype)
18447 
      iprot.readFieldEnd()
18448 
    iprot.readStructEnd()
18449 
 
18450 
  def write(self, oprot):
18451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18453 
      return
18454 
    oprot.writeStructBegin('getInsurer_result')
18455 
    if self.success is not None:
18456 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18457 
      self.success.write(oprot)
18458 
      oprot.writeFieldEnd()
18459 
    oprot.writeFieldStop()
18460 
    oprot.writeStructEnd()
18461 
 
18462 
  def validate(self):
18463 
    return
18464 
 
18465 
 
18466 
  def __repr__(self):
18467 
    L = ['%s=%r' % (key, value)
18468 
      for key, value in self.__dict__.iteritems()]
18469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18470 
 
18471 
  def __eq__(self, other):
18472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18473 
 
18474 
  def __ne__(self, other):
18475 
    return not (self == other)
6838 vikram.rag 18476 
 
18477 
class getAllInsurers_args:
18478 
 
18479 
  thrift_spec = (
18480 
  )
18481 
 
18482 
  def read(self, iprot):
18483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18485 
      return
18486 
    iprot.readStructBegin()
18487 
    while True:
18488 
      (fname, ftype, fid) = iprot.readFieldBegin()
18489 
      if ftype == TType.STOP:
18490 
        break
18491 
      else:
18492 
        iprot.skip(ftype)
18493 
      iprot.readFieldEnd()
18494 
    iprot.readStructEnd()
18495 
 
18496 
  def write(self, oprot):
18497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18499 
      return
18500 
    oprot.writeStructBegin('getAllInsurers_args')
18501 
    oprot.writeFieldStop()
18502 
    oprot.writeStructEnd()
18503 
 
18504 
  def validate(self):
18505 
    return
18506 
 
18507 
 
18508 
  def __repr__(self):
18509 
    L = ['%s=%r' % (key, value)
18510 
      for key, value in self.__dict__.iteritems()]
18511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18512 
 
18513 
  def __eq__(self, other):
18514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18515 
 
18516 
  def __ne__(self, other):
18517 
    return not (self == other)
18518 
 
18519 
class getAllInsurers_result:
18520 
  """
18521 
  Attributes:
18522 
   - success
18523 
  """
18524 
 
18525 
  thrift_spec = (
18526 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18527 
  )
18528 
 
18529 
  def __init__(self, success=None,):
18530 
    self.success = success
18531 
 
18532 
  def read(self, iprot):
18533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18535 
      return
18536 
    iprot.readStructBegin()
18537 
    while True:
18538 
      (fname, ftype, fid) = iprot.readFieldBegin()
18539 
      if ftype == TType.STOP:
18540 
        break
18541 
      if fid == 0:
18542 
        if ftype == TType.LIST:
18543 
          self.success = []
9155 kshitij.so 18544 
          (_etype384, _size381) = iprot.readListBegin()
18545 
          for _i385 in xrange(_size381):
18546 
            _elem386 = Insurer()
18547 
            _elem386.read(iprot)
18548 
            self.success.append(_elem386)
6838 vikram.rag 18549 
          iprot.readListEnd()
18550 
        else:
18551 
          iprot.skip(ftype)
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('getAllInsurers_result')
18562 
    if self.success is not None:
18563 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18564 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18565 
      for iter387 in self.success:
18566 
        iter387.write(oprot)
6838 vikram.rag 18567 
      oprot.writeListEnd()
18568 
      oprot.writeFieldEnd()
18569 
    oprot.writeFieldStop()
18570 
    oprot.writeStructEnd()
18571 
 
18572 
  def validate(self):
18573 
    return
18574 
 
18575 
 
18576 
  def __repr__(self):
18577 
    L = ['%s=%r' % (key, value)
18578 
      for key, value in self.__dict__.iteritems()]
18579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18580 
 
18581 
  def __eq__(self, other):
18582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18583 
 
18584 
  def __ne__(self, other):
18585 
    return not (self == other)
6962 rajveer 18586 
 
18587 
class updateInsuranceDeclaredAmount_args:
18588 
  """
18589 
  Attributes:
18590 
   - insurerId
18591 
   - amount
18592 
  """
18593 
 
18594 
  thrift_spec = (
18595 
    None, # 0
18596 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18597 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18598 
  )
18599 
 
18600 
  def __init__(self, insurerId=None, amount=None,):
18601 
    self.insurerId = insurerId
18602 
    self.amount = amount
18603 
 
18604 
  def read(self, iprot):
18605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18607 
      return
18608 
    iprot.readStructBegin()
18609 
    while True:
18610 
      (fname, ftype, fid) = iprot.readFieldBegin()
18611 
      if ftype == TType.STOP:
18612 
        break
18613 
      if fid == 1:
18614 
        if ftype == TType.I64:
18615 
          self.insurerId = iprot.readI64();
18616 
        else:
18617 
          iprot.skip(ftype)
18618 
      elif fid == 2:
18619 
        if ftype == TType.DOUBLE:
18620 
          self.amount = iprot.readDouble();
18621 
        else:
18622 
          iprot.skip(ftype)
18623 
      else:
18624 
        iprot.skip(ftype)
18625 
      iprot.readFieldEnd()
18626 
    iprot.readStructEnd()
18627 
 
18628 
  def write(self, oprot):
18629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18631 
      return
18632 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18633 
    if self.insurerId is not None:
18634 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18635 
      oprot.writeI64(self.insurerId)
18636 
      oprot.writeFieldEnd()
18637 
    if self.amount is not None:
18638 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18639 
      oprot.writeDouble(self.amount)
18640 
      oprot.writeFieldEnd()
18641 
    oprot.writeFieldStop()
18642 
    oprot.writeStructEnd()
18643 
 
18644 
  def validate(self):
18645 
    return
18646 
 
18647 
 
18648 
  def __repr__(self):
18649 
    L = ['%s=%r' % (key, value)
18650 
      for key, value in self.__dict__.iteritems()]
18651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18652 
 
18653 
  def __eq__(self, other):
18654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18655 
 
18656 
  def __ne__(self, other):
18657 
    return not (self == other)
18658 
 
18659 
class updateInsuranceDeclaredAmount_result:
18660 
 
18661 
  thrift_spec = (
18662 
  )
18663 
 
18664 
  def read(self, iprot):
18665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18667 
      return
18668 
    iprot.readStructBegin()
18669 
    while True:
18670 
      (fname, ftype, fid) = iprot.readFieldBegin()
18671 
      if ftype == TType.STOP:
18672 
        break
18673 
      else:
18674 
        iprot.skip(ftype)
18675 
      iprot.readFieldEnd()
18676 
    iprot.readStructEnd()
18677 
 
18678 
  def write(self, oprot):
18679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18681 
      return
18682 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18683 
    oprot.writeFieldStop()
18684 
    oprot.writeStructEnd()
18685 
 
18686 
  def validate(self):
18687 
    return
18688 
 
18689 
 
18690 
  def __repr__(self):
18691 
    L = ['%s=%r' % (key, value)
18692 
      for key, value in self.__dict__.iteritems()]
18693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18694 
 
18695 
  def __eq__(self, other):
18696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18697 
 
18698 
  def __ne__(self, other):
18699 
    return not (self == other)
7190 amar.kumar 18700 
 
18701 
class getFreebieForItem_args:
18702 
  """
18703 
  Attributes:
18704 
   - itemId
18705 
  """
18706 
 
18707 
  thrift_spec = (
18708 
    None, # 0
18709 
    (1, TType.I64, 'itemId', None, None, ), # 1
18710 
  )
18711 
 
18712 
  def __init__(self, itemId=None,):
18713 
    self.itemId = itemId
18714 
 
18715 
  def read(self, iprot):
18716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18718 
      return
18719 
    iprot.readStructBegin()
18720 
    while True:
18721 
      (fname, ftype, fid) = iprot.readFieldBegin()
18722 
      if ftype == TType.STOP:
18723 
        break
18724 
      if fid == 1:
18725 
        if ftype == TType.I64:
18726 
          self.itemId = iprot.readI64();
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('getFreebieForItem_args')
18739 
    if self.itemId is not None:
18740 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18741 
      oprot.writeI64(self.itemId)
18742 
      oprot.writeFieldEnd()
18743 
    oprot.writeFieldStop()
18744 
    oprot.writeStructEnd()
18745 
 
18746 
  def validate(self):
18747 
    return
18748 
 
18749 
 
18750 
  def __repr__(self):
18751 
    L = ['%s=%r' % (key, value)
18752 
      for key, value in self.__dict__.iteritems()]
18753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18754 
 
18755 
  def __eq__(self, other):
18756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18757 
 
18758 
  def __ne__(self, other):
18759 
    return not (self == other)
18760 
 
18761 
class getFreebieForItem_result:
18762 
  """
18763 
  Attributes:
18764 
   - success
18765 
  """
18766 
 
18767 
  thrift_spec = (
18768 
    (0, TType.I64, 'success', None, None, ), # 0
18769 
  )
18770 
 
18771 
  def __init__(self, success=None,):
18772 
    self.success = success
18773 
 
18774 
  def read(self, iprot):
18775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18777 
      return
18778 
    iprot.readStructBegin()
18779 
    while True:
18780 
      (fname, ftype, fid) = iprot.readFieldBegin()
18781 
      if ftype == TType.STOP:
18782 
        break
18783 
      if fid == 0:
18784 
        if ftype == TType.I64:
18785 
          self.success = iprot.readI64();
18786 
        else:
18787 
          iprot.skip(ftype)
18788 
      else:
18789 
        iprot.skip(ftype)
18790 
      iprot.readFieldEnd()
18791 
    iprot.readStructEnd()
18792 
 
18793 
  def write(self, oprot):
18794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18796 
      return
18797 
    oprot.writeStructBegin('getFreebieForItem_result')
18798 
    if self.success is not None:
18799 
      oprot.writeFieldBegin('success', TType.I64, 0)
18800 
      oprot.writeI64(self.success)
18801 
      oprot.writeFieldEnd()
18802 
    oprot.writeFieldStop()
18803 
    oprot.writeStructEnd()
18804 
 
18805 
  def validate(self):
18806 
    return
18807 
 
18808 
 
18809 
  def __repr__(self):
18810 
    L = ['%s=%r' % (key, value)
18811 
      for key, value in self.__dict__.iteritems()]
18812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18813 
 
18814 
  def __eq__(self, other):
18815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18816 
 
18817 
  def __ne__(self, other):
18818 
    return not (self == other)
18819 
 
18820 
class addOrUpdateFreebieForItem_args:
18821 
  """
18822 
  Attributes:
18823 
   - freebieItem
18824 
  """
18825 
 
18826 
  thrift_spec = (
18827 
    None, # 0
18828 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18829 
  )
18830 
 
18831 
  def __init__(self, freebieItem=None,):
18832 
    self.freebieItem = freebieItem
18833 
 
18834 
  def read(self, iprot):
18835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18837 
      return
18838 
    iprot.readStructBegin()
18839 
    while True:
18840 
      (fname, ftype, fid) = iprot.readFieldBegin()
18841 
      if ftype == TType.STOP:
18842 
        break
18843 
      if fid == 1:
18844 
        if ftype == TType.STRUCT:
18845 
          self.freebieItem = FreebieItem()
18846 
          self.freebieItem.read(iprot)
18847 
        else:
18848 
          iprot.skip(ftype)
18849 
      else:
18850 
        iprot.skip(ftype)
18851 
      iprot.readFieldEnd()
18852 
    iprot.readStructEnd()
18853 
 
18854 
  def write(self, oprot):
18855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18857 
      return
18858 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18859 
    if self.freebieItem is not None:
18860 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18861 
      self.freebieItem.write(oprot)
18862 
      oprot.writeFieldEnd()
18863 
    oprot.writeFieldStop()
18864 
    oprot.writeStructEnd()
18865 
 
18866 
  def validate(self):
18867 
    return
18868 
 
18869 
 
18870 
  def __repr__(self):
18871 
    L = ['%s=%r' % (key, value)
18872 
      for key, value in self.__dict__.iteritems()]
18873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18874 
 
18875 
  def __eq__(self, other):
18876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18877 
 
18878 
  def __ne__(self, other):
18879 
    return not (self == other)
18880 
 
18881 
class addOrUpdateFreebieForItem_result:
18882 
 
18883 
  thrift_spec = (
18884 
  )
18885 
 
18886 
  def read(self, iprot):
18887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18889 
      return
18890 
    iprot.readStructBegin()
18891 
    while True:
18892 
      (fname, ftype, fid) = iprot.readFieldBegin()
18893 
      if ftype == TType.STOP:
18894 
        break
18895 
      else:
18896 
        iprot.skip(ftype)
18897 
      iprot.readFieldEnd()
18898 
    iprot.readStructEnd()
18899 
 
18900 
  def write(self, oprot):
18901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18903 
      return
18904 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18905 
    oprot.writeFieldStop()
18906 
    oprot.writeStructEnd()
18907 
 
18908 
  def validate(self):
18909 
    return
18910 
 
18911 
 
18912 
  def __repr__(self):
18913 
    L = ['%s=%r' % (key, value)
18914 
      for key, value in self.__dict__.iteritems()]
18915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18916 
 
18917 
  def __eq__(self, other):
18918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18919 
 
18920 
  def __ne__(self, other):
18921 
    return not (self == other)
7256 rajveer 18922 
 
7272 amit.gupta 18923 
class addOrUpdateBrandInfo_args:
18924 
  """
18925 
  Attributes:
18926 
   - brandInfo
18927 
  """
18928 
 
18929 
  thrift_spec = (
18930 
    None, # 0
18931 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18932 
  )
18933 
 
18934 
  def __init__(self, brandInfo=None,):
18935 
    self.brandInfo = brandInfo
18936 
 
18937 
  def read(self, iprot):
18938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18940 
      return
18941 
    iprot.readStructBegin()
18942 
    while True:
18943 
      (fname, ftype, fid) = iprot.readFieldBegin()
18944 
      if ftype == TType.STOP:
18945 
        break
18946 
      if fid == 1:
18947 
        if ftype == TType.STRUCT:
18948 
          self.brandInfo = BrandInfo()
18949 
          self.brandInfo.read(iprot)
18950 
        else:
18951 
          iprot.skip(ftype)
18952 
      else:
18953 
        iprot.skip(ftype)
18954 
      iprot.readFieldEnd()
18955 
    iprot.readStructEnd()
18956 
 
18957 
  def write(self, oprot):
18958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18960 
      return
18961 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18962 
    if self.brandInfo is not None:
18963 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18964 
      self.brandInfo.write(oprot)
18965 
      oprot.writeFieldEnd()
18966 
    oprot.writeFieldStop()
18967 
    oprot.writeStructEnd()
18968 
 
18969 
  def validate(self):
18970 
    return
18971 
 
18972 
 
18973 
  def __repr__(self):
18974 
    L = ['%s=%r' % (key, value)
18975 
      for key, value in self.__dict__.iteritems()]
18976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18977 
 
18978 
  def __eq__(self, other):
18979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18980 
 
18981 
  def __ne__(self, other):
18982 
    return not (self == other)
18983 
 
18984 
class addOrUpdateBrandInfo_result:
18985 
 
18986 
  thrift_spec = (
18987 
  )
18988 
 
18989 
  def read(self, iprot):
18990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18992 
      return
18993 
    iprot.readStructBegin()
18994 
    while True:
18995 
      (fname, ftype, fid) = iprot.readFieldBegin()
18996 
      if ftype == TType.STOP:
18997 
        break
18998 
      else:
18999 
        iprot.skip(ftype)
19000 
      iprot.readFieldEnd()
19001 
    iprot.readStructEnd()
19002 
 
19003 
  def write(self, oprot):
19004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19006 
      return
19007 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19008 
    oprot.writeFieldStop()
19009 
    oprot.writeStructEnd()
19010 
 
19011 
  def validate(self):
19012 
    return
19013 
 
19014 
 
19015 
  def __repr__(self):
19016 
    L = ['%s=%r' % (key, value)
19017 
      for key, value in self.__dict__.iteritems()]
19018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19019 
 
19020 
  def __eq__(self, other):
19021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19022 
 
19023 
  def __ne__(self, other):
19024 
    return not (self == other)
19025 
 
19026 
class getBrandInfo_args:
19027 
 
19028 
  thrift_spec = (
19029 
  )
19030 
 
19031 
  def read(self, iprot):
19032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19034 
      return
19035 
    iprot.readStructBegin()
19036 
    while True:
19037 
      (fname, ftype, fid) = iprot.readFieldBegin()
19038 
      if ftype == TType.STOP:
19039 
        break
19040 
      else:
19041 
        iprot.skip(ftype)
19042 
      iprot.readFieldEnd()
19043 
    iprot.readStructEnd()
19044 
 
19045 
  def write(self, oprot):
19046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19048 
      return
19049 
    oprot.writeStructBegin('getBrandInfo_args')
19050 
    oprot.writeFieldStop()
19051 
    oprot.writeStructEnd()
19052 
 
19053 
  def validate(self):
19054 
    return
19055 
 
19056 
 
19057 
  def __repr__(self):
19058 
    L = ['%s=%r' % (key, value)
19059 
      for key, value in self.__dict__.iteritems()]
19060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19061 
 
19062 
  def __eq__(self, other):
19063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19064 
 
19065 
  def __ne__(self, other):
19066 
    return not (self == other)
19067 
 
19068 
class getBrandInfo_result:
19069 
  """
19070 
  Attributes:
19071 
   - success
19072 
  """
19073 
 
19074 
  thrift_spec = (
19075 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19076 
  )
19077 
 
19078 
  def __init__(self, success=None,):
19079 
    self.success = success
19080 
 
19081 
  def read(self, iprot):
19082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19084 
      return
19085 
    iprot.readStructBegin()
19086 
    while True:
19087 
      (fname, ftype, fid) = iprot.readFieldBegin()
19088 
      if ftype == TType.STOP:
19089 
        break
19090 
      if fid == 0:
19091 
        if ftype == TType.MAP:
19092 
          self.success = {}
9155 kshitij.so 19093 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19094 
          for _i392 in xrange(_size388):
19095 
            _key393 = iprot.readString();
19096 
            _val394 = BrandInfo()
19097 
            _val394.read(iprot)
19098 
            self.success[_key393] = _val394
7272 amit.gupta 19099 
          iprot.readMapEnd()
19100 
        else:
19101 
          iprot.skip(ftype)
19102 
      else:
19103 
        iprot.skip(ftype)
19104 
      iprot.readFieldEnd()
19105 
    iprot.readStructEnd()
19106 
 
19107 
  def write(self, oprot):
19108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19110 
      return
19111 
    oprot.writeStructBegin('getBrandInfo_result')
19112 
    if self.success is not None:
19113 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19114 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19115 
      for kiter395,viter396 in self.success.items():
19116 
        oprot.writeString(kiter395)
19117 
        viter396.write(oprot)
7272 amit.gupta 19118 
      oprot.writeMapEnd()
19119 
      oprot.writeFieldEnd()
19120 
    oprot.writeFieldStop()
19121 
    oprot.writeStructEnd()
19122 
 
19123 
  def validate(self):
19124 
    return
19125 
 
19126 
 
19127 
  def __repr__(self):
19128 
    L = ['%s=%r' % (key, value)
19129 
      for key, value in self.__dict__.iteritems()]
19130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19131 
 
19132 
  def __eq__(self, other):
19133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19134 
 
19135 
  def __ne__(self, other):
19136 
    return not (self == other)
19137 
 
7256 rajveer 19138 
class getStorePricing_args:
19139 
  """
19140 
  Attributes:
19141 
   - itemId
19142 
  """
19143 
 
19144 
  thrift_spec = (
19145 
    None, # 0
19146 
    (1, TType.I64, 'itemId', None, None, ), # 1
19147 
  )
19148 
 
19149 
  def __init__(self, itemId=None,):
19150 
    self.itemId = itemId
19151 
 
19152 
  def read(self, iprot):
19153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19155 
      return
19156 
    iprot.readStructBegin()
19157 
    while True:
19158 
      (fname, ftype, fid) = iprot.readFieldBegin()
19159 
      if ftype == TType.STOP:
19160 
        break
19161 
      if fid == 1:
19162 
        if ftype == TType.I64:
19163 
          self.itemId = iprot.readI64();
19164 
        else:
19165 
          iprot.skip(ftype)
19166 
      else:
19167 
        iprot.skip(ftype)
19168 
      iprot.readFieldEnd()
19169 
    iprot.readStructEnd()
19170 
 
19171 
  def write(self, oprot):
19172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19174 
      return
19175 
    oprot.writeStructBegin('getStorePricing_args')
19176 
    if self.itemId is not None:
19177 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19178 
      oprot.writeI64(self.itemId)
19179 
      oprot.writeFieldEnd()
19180 
    oprot.writeFieldStop()
19181 
    oprot.writeStructEnd()
19182 
 
19183 
  def validate(self):
19184 
    return
19185 
 
19186 
 
19187 
  def __repr__(self):
19188 
    L = ['%s=%r' % (key, value)
19189 
      for key, value in self.__dict__.iteritems()]
19190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19191 
 
19192 
  def __eq__(self, other):
19193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19194 
 
19195 
  def __ne__(self, other):
19196 
    return not (self == other)
19197 
 
19198 
class getStorePricing_result:
19199 
  """
19200 
  Attributes:
19201 
   - success
19202 
  """
19203 
 
19204 
  thrift_spec = (
19205 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19206 
  )
19207 
 
19208 
  def __init__(self, success=None,):
19209 
    self.success = success
19210 
 
19211 
  def read(self, iprot):
19212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19214 
      return
19215 
    iprot.readStructBegin()
19216 
    while True:
19217 
      (fname, ftype, fid) = iprot.readFieldBegin()
19218 
      if ftype == TType.STOP:
19219 
        break
19220 
      if fid == 0:
19221 
        if ftype == TType.STRUCT:
19222 
          self.success = StorePricing()
19223 
          self.success.read(iprot)
19224 
        else:
19225 
          iprot.skip(ftype)
19226 
      else:
19227 
        iprot.skip(ftype)
19228 
      iprot.readFieldEnd()
19229 
    iprot.readStructEnd()
19230 
 
19231 
  def write(self, oprot):
19232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19234 
      return
19235 
    oprot.writeStructBegin('getStorePricing_result')
19236 
    if self.success is not None:
19237 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19238 
      self.success.write(oprot)
19239 
      oprot.writeFieldEnd()
19240 
    oprot.writeFieldStop()
19241 
    oprot.writeStructEnd()
19242 
 
19243 
  def validate(self):
19244 
    return
19245 
 
19246 
 
19247 
  def __repr__(self):
19248 
    L = ['%s=%r' % (key, value)
19249 
      for key, value in self.__dict__.iteritems()]
19250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19251 
 
19252 
  def __eq__(self, other):
19253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19254 
 
19255 
  def __ne__(self, other):
19256 
    return not (self == other)
7265 rajveer 19257 
 
7306 rajveer 19258 
class getStorePricings_args:
19259 
  """
19260 
  Attributes:
19261 
   - itemIds
19262 
  """
19263 
 
19264 
  thrift_spec = (
19265 
    None, # 0
19266 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19267 
  )
19268 
 
19269 
  def __init__(self, itemIds=None,):
19270 
    self.itemIds = itemIds
19271 
 
19272 
  def read(self, iprot):
19273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19275 
      return
19276 
    iprot.readStructBegin()
19277 
    while True:
19278 
      (fname, ftype, fid) = iprot.readFieldBegin()
19279 
      if ftype == TType.STOP:
19280 
        break
19281 
      if fid == 1:
19282 
        if ftype == TType.LIST:
19283 
          self.itemIds = []
9155 kshitij.so 19284 
          (_etype400, _size397) = iprot.readListBegin()
19285 
          for _i401 in xrange(_size397):
19286 
            _elem402 = iprot.readI64();
19287 
            self.itemIds.append(_elem402)
7306 rajveer 19288 
          iprot.readListEnd()
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('getStorePricings_args')
19301 
    if self.itemIds is not None:
19302 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19303 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19304 
      for iter403 in self.itemIds:
19305 
        oprot.writeI64(iter403)
7306 rajveer 19306 
      oprot.writeListEnd()
19307 
      oprot.writeFieldEnd()
19308 
    oprot.writeFieldStop()
19309 
    oprot.writeStructEnd()
19310 
 
19311 
  def validate(self):
19312 
    return
19313 
 
19314 
 
19315 
  def __repr__(self):
19316 
    L = ['%s=%r' % (key, value)
19317 
      for key, value in self.__dict__.iteritems()]
19318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19319 
 
19320 
  def __eq__(self, other):
19321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19322 
 
19323 
  def __ne__(self, other):
19324 
    return not (self == other)
19325 
 
19326 
class getStorePricings_result:
19327 
  """
19328 
  Attributes:
19329 
   - success
19330 
  """
19331 
 
19332 
  thrift_spec = (
19333 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19334 
  )
19335 
 
19336 
  def __init__(self, success=None,):
19337 
    self.success = success
19338 
 
19339 
  def read(self, iprot):
19340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19342 
      return
19343 
    iprot.readStructBegin()
19344 
    while True:
19345 
      (fname, ftype, fid) = iprot.readFieldBegin()
19346 
      if ftype == TType.STOP:
19347 
        break
19348 
      if fid == 0:
19349 
        if ftype == TType.LIST:
19350 
          self.success = []
9155 kshitij.so 19351 
          (_etype407, _size404) = iprot.readListBegin()
19352 
          for _i408 in xrange(_size404):
19353 
            _elem409 = StorePricing()
19354 
            _elem409.read(iprot)
19355 
            self.success.append(_elem409)
7306 rajveer 19356 
          iprot.readListEnd()
19357 
        else:
19358 
          iprot.skip(ftype)
19359 
      else:
19360 
        iprot.skip(ftype)
19361 
      iprot.readFieldEnd()
19362 
    iprot.readStructEnd()
19363 
 
19364 
  def write(self, oprot):
19365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19367 
      return
19368 
    oprot.writeStructBegin('getStorePricings_result')
19369 
    if self.success is not None:
19370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19372 
      for iter410 in self.success:
19373 
        iter410.write(oprot)
7306 rajveer 19374 
      oprot.writeListEnd()
19375 
      oprot.writeFieldEnd()
19376 
    oprot.writeFieldStop()
19377 
    oprot.writeStructEnd()
19378 
 
19379 
  def validate(self):
19380 
    return
19381 
 
19382 
 
19383 
  def __repr__(self):
19384 
    L = ['%s=%r' % (key, value)
19385 
      for key, value in self.__dict__.iteritems()]
19386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19387 
 
19388 
  def __eq__(self, other):
19389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19390 
 
19391 
  def __ne__(self, other):
19392 
    return not (self == other)
19393 
 
7265 rajveer 19394 
class updateStorePricing_args:
19395 
  """
19396 
  Attributes:
19397 
   - sp
7382 rajveer 19398 
   - allColors
7265 rajveer 19399 
  """
19400 
 
19401 
  thrift_spec = (
19402 
    None, # 0
19403 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19404 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19405 
  )
19406 
 
7382 rajveer 19407 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19408 
    self.sp = sp
7382 rajveer 19409 
    self.allColors = allColors
7265 rajveer 19410 
 
19411 
  def read(self, iprot):
19412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19414 
      return
19415 
    iprot.readStructBegin()
19416 
    while True:
19417 
      (fname, ftype, fid) = iprot.readFieldBegin()
19418 
      if ftype == TType.STOP:
19419 
        break
19420 
      if fid == 1:
19421 
        if ftype == TType.STRUCT:
19422 
          self.sp = StorePricing()
19423 
          self.sp.read(iprot)
19424 
        else:
19425 
          iprot.skip(ftype)
7382 rajveer 19426 
      elif fid == 2:
19427 
        if ftype == TType.BOOL:
19428 
          self.allColors = iprot.readBool();
19429 
        else:
19430 
          iprot.skip(ftype)
7265 rajveer 19431 
      else:
19432 
        iprot.skip(ftype)
19433 
      iprot.readFieldEnd()
19434 
    iprot.readStructEnd()
19435 
 
19436 
  def write(self, oprot):
19437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19439 
      return
19440 
    oprot.writeStructBegin('updateStorePricing_args')
19441 
    if self.sp is not None:
19442 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19443 
      self.sp.write(oprot)
19444 
      oprot.writeFieldEnd()
7382 rajveer 19445 
    if self.allColors is not None:
19446 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19447 
      oprot.writeBool(self.allColors)
19448 
      oprot.writeFieldEnd()
7265 rajveer 19449 
    oprot.writeFieldStop()
19450 
    oprot.writeStructEnd()
19451 
 
19452 
  def validate(self):
19453 
    return
19454 
 
19455 
 
19456 
  def __repr__(self):
19457 
    L = ['%s=%r' % (key, value)
19458 
      for key, value in self.__dict__.iteritems()]
19459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19460 
 
19461 
  def __eq__(self, other):
19462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19463 
 
19464 
  def __ne__(self, other):
19465 
    return not (self == other)
19466 
 
19467 
class updateStorePricing_result:
19468 
 
19469 
  thrift_spec = (
19470 
  )
19471 
 
19472 
  def read(self, iprot):
19473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19475 
      return
19476 
    iprot.readStructBegin()
19477 
    while True:
19478 
      (fname, ftype, fid) = iprot.readFieldBegin()
19479 
      if ftype == TType.STOP:
19480 
        break
19481 
      else:
19482 
        iprot.skip(ftype)
19483 
      iprot.readFieldEnd()
19484 
    iprot.readStructEnd()
19485 
 
19486 
  def write(self, oprot):
19487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19489 
      return
19490 
    oprot.writeStructBegin('updateStorePricing_result')
19491 
    oprot.writeFieldStop()
19492 
    oprot.writeStructEnd()
19493 
 
19494 
  def validate(self):
19495 
    return
19496 
 
19497 
 
19498 
  def __repr__(self):
19499 
    L = ['%s=%r' % (key, value)
19500 
      for key, value in self.__dict__.iteritems()]
19501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19502 
 
19503 
  def __eq__(self, other):
19504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19505 
 
19506 
  def __ne__(self, other):
19507 
    return not (self == other)
7281 kshitij.so 19508 
 
19509 
class getAllAmazonListedItems_args:
19510 
 
19511 
  thrift_spec = (
19512 
  )
19513 
 
19514 
  def read(self, iprot):
19515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19517 
      return
19518 
    iprot.readStructBegin()
19519 
    while True:
19520 
      (fname, ftype, fid) = iprot.readFieldBegin()
19521 
      if ftype == TType.STOP:
19522 
        break
19523 
      else:
19524 
        iprot.skip(ftype)
19525 
      iprot.readFieldEnd()
19526 
    iprot.readStructEnd()
19527 
 
19528 
  def write(self, oprot):
19529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19531 
      return
19532 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19533 
    oprot.writeFieldStop()
19534 
    oprot.writeStructEnd()
19535 
 
19536 
  def validate(self):
19537 
    return
19538 
 
19539 
 
19540 
  def __repr__(self):
19541 
    L = ['%s=%r' % (key, value)
19542 
      for key, value in self.__dict__.iteritems()]
19543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19544 
 
19545 
  def __eq__(self, other):
19546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19547 
 
19548 
  def __ne__(self, other):
19549 
    return not (self == other)
19550 
 
19551 
class getAllAmazonListedItems_result:
19552 
  """
19553 
  Attributes:
19554 
   - success
19555 
  """
19556 
 
19557 
  thrift_spec = (
19558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19559 
  )
19560 
 
19561 
  def __init__(self, success=None,):
19562 
    self.success = success
19563 
 
19564 
  def read(self, iprot):
19565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19567 
      return
19568 
    iprot.readStructBegin()
19569 
    while True:
19570 
      (fname, ftype, fid) = iprot.readFieldBegin()
19571 
      if ftype == TType.STOP:
19572 
        break
19573 
      if fid == 0:
19574 
        if ftype == TType.LIST:
19575 
          self.success = []
9155 kshitij.so 19576 
          (_etype414, _size411) = iprot.readListBegin()
19577 
          for _i415 in xrange(_size411):
19578 
            _elem416 = Amazonlisted()
19579 
            _elem416.read(iprot)
19580 
            self.success.append(_elem416)
7281 kshitij.so 19581 
          iprot.readListEnd()
19582 
        else:
19583 
          iprot.skip(ftype)
19584 
      else:
19585 
        iprot.skip(ftype)
19586 
      iprot.readFieldEnd()
19587 
    iprot.readStructEnd()
19588 
 
19589 
  def write(self, oprot):
19590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19592 
      return
19593 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19594 
    if self.success is not None:
19595 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19596 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19597 
      for iter417 in self.success:
19598 
        iter417.write(oprot)
7281 kshitij.so 19599 
      oprot.writeListEnd()
19600 
      oprot.writeFieldEnd()
19601 
    oprot.writeFieldStop()
19602 
    oprot.writeStructEnd()
19603 
 
19604 
  def validate(self):
19605 
    return
19606 
 
19607 
 
19608 
  def __repr__(self):
19609 
    L = ['%s=%r' % (key, value)
19610 
      for key, value in self.__dict__.iteritems()]
19611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19612 
 
19613 
  def __eq__(self, other):
19614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19615 
 
19616 
  def __ne__(self, other):
19617 
    return not (self == other)
19618 
 
8619 kshitij.so 19619 
class searchAmazonItems_args:
19620 
  """
19621 
  Attributes:
19622 
   - searchTerm
19623 
   - offset
19624 
   - limit
19625 
  """
19626 
 
19627 
  thrift_spec = (
19628 
    None, # 0
19629 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19630 
    (2, TType.I64, 'offset', None, None, ), # 2
19631 
    (3, TType.I64, 'limit', None, None, ), # 3
19632 
  )
19633 
 
19634 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19635 
    self.searchTerm = searchTerm
19636 
    self.offset = offset
19637 
    self.limit = limit
19638 
 
19639 
  def read(self, iprot):
19640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19642 
      return
19643 
    iprot.readStructBegin()
19644 
    while True:
19645 
      (fname, ftype, fid) = iprot.readFieldBegin()
19646 
      if ftype == TType.STOP:
19647 
        break
19648 
      if fid == 1:
19649 
        if ftype == TType.LIST:
19650 
          self.searchTerm = []
9155 kshitij.so 19651 
          (_etype421, _size418) = iprot.readListBegin()
19652 
          for _i422 in xrange(_size418):
19653 
            _elem423 = iprot.readString();
19654 
            self.searchTerm.append(_elem423)
8619 kshitij.so 19655 
          iprot.readListEnd()
19656 
        else:
19657 
          iprot.skip(ftype)
19658 
      elif fid == 2:
19659 
        if ftype == TType.I64:
19660 
          self.offset = iprot.readI64();
19661 
        else:
19662 
          iprot.skip(ftype)
19663 
      elif fid == 3:
19664 
        if ftype == TType.I64:
19665 
          self.limit = iprot.readI64();
19666 
        else:
19667 
          iprot.skip(ftype)
19668 
      else:
19669 
        iprot.skip(ftype)
19670 
      iprot.readFieldEnd()
19671 
    iprot.readStructEnd()
19672 
 
19673 
  def write(self, oprot):
19674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19676 
      return
19677 
    oprot.writeStructBegin('searchAmazonItems_args')
19678 
    if self.searchTerm is not None:
19679 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19680 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19681 
      for iter424 in self.searchTerm:
19682 
        oprot.writeString(iter424)
8619 kshitij.so 19683 
      oprot.writeListEnd()
19684 
      oprot.writeFieldEnd()
19685 
    if self.offset is not None:
19686 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19687 
      oprot.writeI64(self.offset)
19688 
      oprot.writeFieldEnd()
19689 
    if self.limit is not None:
19690 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19691 
      oprot.writeI64(self.limit)
19692 
      oprot.writeFieldEnd()
19693 
    oprot.writeFieldStop()
19694 
    oprot.writeStructEnd()
19695 
 
19696 
  def validate(self):
19697 
    return
19698 
 
19699 
 
19700 
  def __repr__(self):
19701 
    L = ['%s=%r' % (key, value)
19702 
      for key, value in self.__dict__.iteritems()]
19703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19704 
 
19705 
  def __eq__(self, other):
19706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19707 
 
19708 
  def __ne__(self, other):
19709 
    return not (self == other)
19710 
 
19711 
class searchAmazonItems_result:
19712 
  """
19713 
  Attributes:
19714 
   - success
19715 
  """
19716 
 
19717 
  thrift_spec = (
19718 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19719 
  )
19720 
 
19721 
  def __init__(self, success=None,):
19722 
    self.success = success
19723 
 
19724 
  def read(self, iprot):
19725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19727 
      return
19728 
    iprot.readStructBegin()
19729 
    while True:
19730 
      (fname, ftype, fid) = iprot.readFieldBegin()
19731 
      if ftype == TType.STOP:
19732 
        break
19733 
      if fid == 0:
19734 
        if ftype == TType.LIST:
19735 
          self.success = []
9155 kshitij.so 19736 
          (_etype428, _size425) = iprot.readListBegin()
19737 
          for _i429 in xrange(_size425):
19738 
            _elem430 = Amazonlisted()
19739 
            _elem430.read(iprot)
19740 
            self.success.append(_elem430)
8619 kshitij.so 19741 
          iprot.readListEnd()
19742 
        else:
19743 
          iprot.skip(ftype)
19744 
      else:
19745 
        iprot.skip(ftype)
19746 
      iprot.readFieldEnd()
19747 
    iprot.readStructEnd()
19748 
 
19749 
  def write(self, oprot):
19750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19752 
      return
19753 
    oprot.writeStructBegin('searchAmazonItems_result')
19754 
    if self.success is not None:
19755 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19756 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19757 
      for iter431 in self.success:
19758 
        iter431.write(oprot)
8619 kshitij.so 19759 
      oprot.writeListEnd()
19760 
      oprot.writeFieldEnd()
19761 
    oprot.writeFieldStop()
19762 
    oprot.writeStructEnd()
19763 
 
19764 
  def validate(self):
19765 
    return
19766 
 
19767 
 
19768 
  def __repr__(self):
19769 
    L = ['%s=%r' % (key, value)
19770 
      for key, value in self.__dict__.iteritems()]
19771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19772 
 
19773 
  def __eq__(self, other):
19774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19775 
 
19776 
  def __ne__(self, other):
19777 
    return not (self == other)
19778 
 
19779 
class getAmazonSearchResultCount_args:
19780 
  """
19781 
  Attributes:
19782 
   - searchTerm
19783 
  """
19784 
 
19785 
  thrift_spec = (
19786 
    None, # 0
19787 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19788 
  )
19789 
 
19790 
  def __init__(self, searchTerm=None,):
19791 
    self.searchTerm = searchTerm
19792 
 
19793 
  def read(self, iprot):
19794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19796 
      return
19797 
    iprot.readStructBegin()
19798 
    while True:
19799 
      (fname, ftype, fid) = iprot.readFieldBegin()
19800 
      if ftype == TType.STOP:
19801 
        break
19802 
      if fid == 1:
19803 
        if ftype == TType.LIST:
19804 
          self.searchTerm = []
9155 kshitij.so 19805 
          (_etype435, _size432) = iprot.readListBegin()
19806 
          for _i436 in xrange(_size432):
19807 
            _elem437 = iprot.readString();
19808 
            self.searchTerm.append(_elem437)
8619 kshitij.so 19809 
          iprot.readListEnd()
19810 
        else:
19811 
          iprot.skip(ftype)
19812 
      else:
19813 
        iprot.skip(ftype)
19814 
      iprot.readFieldEnd()
19815 
    iprot.readStructEnd()
19816 
 
19817 
  def write(self, oprot):
19818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19820 
      return
19821 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19822 
    if self.searchTerm is not None:
19823 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19824 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19825 
      for iter438 in self.searchTerm:
19826 
        oprot.writeString(iter438)
8619 kshitij.so 19827 
      oprot.writeListEnd()
19828 
      oprot.writeFieldEnd()
19829 
    oprot.writeFieldStop()
19830 
    oprot.writeStructEnd()
19831 
 
19832 
  def validate(self):
19833 
    return
19834 
 
19835 
 
19836 
  def __repr__(self):
19837 
    L = ['%s=%r' % (key, value)
19838 
      for key, value in self.__dict__.iteritems()]
19839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19840 
 
19841 
  def __eq__(self, other):
19842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19843 
 
19844 
  def __ne__(self, other):
19845 
    return not (self == other)
19846 
 
19847 
class getAmazonSearchResultCount_result:
19848 
  """
19849 
  Attributes:
19850 
   - success
19851 
  """
19852 
 
19853 
  thrift_spec = (
19854 
    (0, TType.I64, 'success', None, None, ), # 0
19855 
  )
19856 
 
19857 
  def __init__(self, success=None,):
19858 
    self.success = success
19859 
 
19860 
  def read(self, iprot):
19861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19863 
      return
19864 
    iprot.readStructBegin()
19865 
    while True:
19866 
      (fname, ftype, fid) = iprot.readFieldBegin()
19867 
      if ftype == TType.STOP:
19868 
        break
19869 
      if fid == 0:
19870 
        if ftype == TType.I64:
19871 
          self.success = iprot.readI64();
19872 
        else:
19873 
          iprot.skip(ftype)
19874 
      else:
19875 
        iprot.skip(ftype)
19876 
      iprot.readFieldEnd()
19877 
    iprot.readStructEnd()
19878 
 
19879 
  def write(self, oprot):
19880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19882 
      return
19883 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19884 
    if self.success is not None:
19885 
      oprot.writeFieldBegin('success', TType.I64, 0)
19886 
      oprot.writeI64(self.success)
19887 
      oprot.writeFieldEnd()
19888 
    oprot.writeFieldStop()
19889 
    oprot.writeStructEnd()
19890 
 
19891 
  def validate(self):
19892 
    return
19893 
 
19894 
 
19895 
  def __repr__(self):
19896 
    L = ['%s=%r' % (key, value)
19897 
      for key, value in self.__dict__.iteritems()]
19898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19899 
 
19900 
  def __eq__(self, other):
19901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19902 
 
19903 
  def __ne__(self, other):
19904 
    return not (self == other)
19905 
 
19906 
class getCountForAmazonlistedItems_args:
19907 
 
19908 
  thrift_spec = (
19909 
  )
19910 
 
19911 
  def read(self, iprot):
19912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19914 
      return
19915 
    iprot.readStructBegin()
19916 
    while True:
19917 
      (fname, ftype, fid) = iprot.readFieldBegin()
19918 
      if ftype == TType.STOP:
19919 
        break
19920 
      else:
19921 
        iprot.skip(ftype)
19922 
      iprot.readFieldEnd()
19923 
    iprot.readStructEnd()
19924 
 
19925 
  def write(self, oprot):
19926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19928 
      return
19929 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19930 
    oprot.writeFieldStop()
19931 
    oprot.writeStructEnd()
19932 
 
19933 
  def validate(self):
19934 
    return
19935 
 
19936 
 
19937 
  def __repr__(self):
19938 
    L = ['%s=%r' % (key, value)
19939 
      for key, value in self.__dict__.iteritems()]
19940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19941 
 
19942 
  def __eq__(self, other):
19943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19944 
 
19945 
  def __ne__(self, other):
19946 
    return not (self == other)
19947 
 
19948 
class getCountForAmazonlistedItems_result:
19949 
  """
19950 
  Attributes:
19951 
   - success
19952 
  """
19953 
 
19954 
  thrift_spec = (
19955 
    (0, TType.I64, 'success', None, None, ), # 0
19956 
  )
19957 
 
19958 
  def __init__(self, success=None,):
19959 
    self.success = success
19960 
 
19961 
  def read(self, iprot):
19962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19964 
      return
19965 
    iprot.readStructBegin()
19966 
    while True:
19967 
      (fname, ftype, fid) = iprot.readFieldBegin()
19968 
      if ftype == TType.STOP:
19969 
        break
19970 
      if fid == 0:
19971 
        if ftype == TType.I64:
19972 
          self.success = iprot.readI64();
19973 
        else:
19974 
          iprot.skip(ftype)
19975 
      else:
19976 
        iprot.skip(ftype)
19977 
      iprot.readFieldEnd()
19978 
    iprot.readStructEnd()
19979 
 
19980 
  def write(self, oprot):
19981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19983 
      return
19984 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
19985 
    if self.success is not None:
19986 
      oprot.writeFieldBegin('success', TType.I64, 0)
19987 
      oprot.writeI64(self.success)
19988 
      oprot.writeFieldEnd()
19989 
    oprot.writeFieldStop()
19990 
    oprot.writeStructEnd()
19991 
 
19992 
  def validate(self):
19993 
    return
19994 
 
19995 
 
19996 
  def __repr__(self):
19997 
    L = ['%s=%r' % (key, value)
19998 
      for key, value in self.__dict__.iteritems()]
19999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20000 
 
20001 
  def __eq__(self, other):
20002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20003 
 
20004 
  def __ne__(self, other):
20005 
    return not (self == other)
20006 
 
7281 kshitij.so 20007 
class getAmazonItemDetails_args:
20008 
  """
20009 
  Attributes:
20010 
   - itemId
20011 
  """
20012 
 
20013 
  thrift_spec = (
20014 
    None, # 0
20015 
    (1, TType.I64, 'itemId', None, None, ), # 1
20016 
  )
20017 
 
20018 
  def __init__(self, itemId=None,):
20019 
    self.itemId = itemId
20020 
 
20021 
  def read(self, iprot):
20022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20024 
      return
20025 
    iprot.readStructBegin()
20026 
    while True:
20027 
      (fname, ftype, fid) = iprot.readFieldBegin()
20028 
      if ftype == TType.STOP:
20029 
        break
20030 
      if fid == 1:
20031 
        if ftype == TType.I64:
20032 
          self.itemId = iprot.readI64();
20033 
        else:
20034 
          iprot.skip(ftype)
20035 
      else:
20036 
        iprot.skip(ftype)
20037 
      iprot.readFieldEnd()
20038 
    iprot.readStructEnd()
20039 
 
20040 
  def write(self, oprot):
20041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20043 
      return
20044 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20045 
    if self.itemId is not None:
20046 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20047 
      oprot.writeI64(self.itemId)
20048 
      oprot.writeFieldEnd()
20049 
    oprot.writeFieldStop()
20050 
    oprot.writeStructEnd()
20051 
 
20052 
  def validate(self):
20053 
    return
20054 
 
20055 
 
20056 
  def __repr__(self):
20057 
    L = ['%s=%r' % (key, value)
20058 
      for key, value in self.__dict__.iteritems()]
20059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20060 
 
20061 
  def __eq__(self, other):
20062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20063 
 
20064 
  def __ne__(self, other):
20065 
    return not (self == other)
20066 
 
20067 
class getAmazonItemDetails_result:
20068 
  """
20069 
  Attributes:
20070 
   - success
20071 
  """
20072 
 
20073 
  thrift_spec = (
20074 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20075 
  )
20076 
 
20077 
  def __init__(self, success=None,):
20078 
    self.success = success
20079 
 
20080 
  def read(self, iprot):
20081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20083 
      return
20084 
    iprot.readStructBegin()
20085 
    while True:
20086 
      (fname, ftype, fid) = iprot.readFieldBegin()
20087 
      if ftype == TType.STOP:
20088 
        break
20089 
      if fid == 0:
20090 
        if ftype == TType.STRUCT:
20091 
          self.success = Amazonlisted()
20092 
          self.success.read(iprot)
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20105 
    if self.success is not None:
20106 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20107 
      self.success.write(oprot)
20108 
      oprot.writeFieldEnd()
20109 
    oprot.writeFieldStop()
20110 
    oprot.writeStructEnd()
20111 
 
20112 
  def validate(self):
20113 
    return
20114 
 
20115 
 
20116 
  def __repr__(self):
20117 
    L = ['%s=%r' % (key, value)
20118 
      for key, value in self.__dict__.iteritems()]
20119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20120 
 
20121 
  def __eq__(self, other):
20122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20123 
 
20124 
  def __ne__(self, other):
20125 
    return not (self == other)
20126 
 
20127 
class updateAmazonItemDetails_args:
20128 
  """
20129 
  Attributes:
8168 kshitij.so 20130 
   - amazonlisted
7281 kshitij.so 20131 
  """
20132 
 
20133 
  thrift_spec = (
20134 
    None, # 0
8168 kshitij.so 20135 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20136 
  )
20137 
 
8168 kshitij.so 20138 
  def __init__(self, amazonlisted=None,):
20139 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20140 
 
20141 
  def read(self, iprot):
20142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20144 
      return
20145 
    iprot.readStructBegin()
20146 
    while True:
20147 
      (fname, ftype, fid) = iprot.readFieldBegin()
20148 
      if ftype == TType.STOP:
20149 
        break
20150 
      if fid == 1:
8168 kshitij.so 20151 
        if ftype == TType.STRUCT:
20152 
          self.amazonlisted = Amazonlisted()
20153 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20154 
        else:
20155 
          iprot.skip(ftype)
20156 
      else:
20157 
        iprot.skip(ftype)
20158 
      iprot.readFieldEnd()
20159 
    iprot.readStructEnd()
20160 
 
20161 
  def write(self, oprot):
20162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20164 
      return
20165 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20166 
    if self.amazonlisted is not None:
20167 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20168 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20169 
      oprot.writeFieldEnd()
20170 
    oprot.writeFieldStop()
20171 
    oprot.writeStructEnd()
20172 
 
20173 
  def validate(self):
20174 
    return
20175 
 
20176 
 
20177 
  def __repr__(self):
20178 
    L = ['%s=%r' % (key, value)
20179 
      for key, value in self.__dict__.iteritems()]
20180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20181 
 
20182 
  def __eq__(self, other):
20183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20184 
 
20185 
  def __ne__(self, other):
20186 
    return not (self == other)
20187 
 
20188 
class updateAmazonItemDetails_result:
20189 
 
20190 
  thrift_spec = (
20191 
  )
20192 
 
20193 
  def read(self, iprot):
20194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20196 
      return
20197 
    iprot.readStructBegin()
20198 
    while True:
20199 
      (fname, ftype, fid) = iprot.readFieldBegin()
20200 
      if ftype == TType.STOP:
20201 
        break
20202 
      else:
20203 
        iprot.skip(ftype)
20204 
      iprot.readFieldEnd()
20205 
    iprot.readStructEnd()
20206 
 
20207 
  def write(self, oprot):
20208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20210 
      return
20211 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20212 
    oprot.writeFieldStop()
20213 
    oprot.writeStructEnd()
20214 
 
20215 
  def validate(self):
20216 
    return
20217 
 
20218 
 
20219 
  def __repr__(self):
20220 
    L = ['%s=%r' % (key, value)
20221 
      for key, value in self.__dict__.iteritems()]
20222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20223 
 
20224 
  def __eq__(self, other):
20225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20226 
 
20227 
  def __ne__(self, other):
20228 
    return not (self == other)
20229 
 
20230 
class addAmazonItem_args:
20231 
  """
20232 
  Attributes:
20233 
   - amazonlisted
20234 
  """
20235 
 
20236 
  thrift_spec = (
20237 
    None, # 0
20238 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20239 
  )
20240 
 
20241 
  def __init__(self, amazonlisted=None,):
20242 
    self.amazonlisted = amazonlisted
20243 
 
20244 
  def read(self, iprot):
20245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20247 
      return
20248 
    iprot.readStructBegin()
20249 
    while True:
20250 
      (fname, ftype, fid) = iprot.readFieldBegin()
20251 
      if ftype == TType.STOP:
20252 
        break
20253 
      if fid == 1:
20254 
        if ftype == TType.STRUCT:
20255 
          self.amazonlisted = Amazonlisted()
20256 
          self.amazonlisted.read(iprot)
20257 
        else:
20258 
          iprot.skip(ftype)
20259 
      else:
20260 
        iprot.skip(ftype)
20261 
      iprot.readFieldEnd()
20262 
    iprot.readStructEnd()
20263 
 
20264 
  def write(self, oprot):
20265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20267 
      return
20268 
    oprot.writeStructBegin('addAmazonItem_args')
20269 
    if self.amazonlisted is not None:
20270 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20271 
      self.amazonlisted.write(oprot)
20272 
      oprot.writeFieldEnd()
20273 
    oprot.writeFieldStop()
20274 
    oprot.writeStructEnd()
20275 
 
20276 
  def validate(self):
20277 
    return
20278 
 
20279 
 
20280 
  def __repr__(self):
20281 
    L = ['%s=%r' % (key, value)
20282 
      for key, value in self.__dict__.iteritems()]
20283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20284 
 
20285 
  def __eq__(self, other):
20286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20287 
 
20288 
  def __ne__(self, other):
20289 
    return not (self == other)
20290 
 
20291 
class addAmazonItem_result:
20292 
 
20293 
  thrift_spec = (
20294 
  )
20295 
 
20296 
  def read(self, iprot):
20297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20299 
      return
20300 
    iprot.readStructBegin()
20301 
    while True:
20302 
      (fname, ftype, fid) = iprot.readFieldBegin()
20303 
      if ftype == TType.STOP:
20304 
        break
20305 
      else:
20306 
        iprot.skip(ftype)
20307 
      iprot.readFieldEnd()
20308 
    iprot.readStructEnd()
20309 
 
20310 
  def write(self, oprot):
20311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20313 
      return
20314 
    oprot.writeStructBegin('addAmazonItem_result')
20315 
    oprot.writeFieldStop()
20316 
    oprot.writeStructEnd()
20317 
 
20318 
  def validate(self):
20319 
    return
20320 
 
20321 
 
20322 
  def __repr__(self):
20323 
    L = ['%s=%r' % (key, value)
20324 
      for key, value in self.__dict__.iteritems()]
20325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20326 
 
20327 
  def __eq__(self, other):
20328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20329 
 
20330 
  def __ne__(self, other):
20331 
    return not (self == other)
7291 vikram.rag 20332 
 
20333 
class getAsinItems_args:
20334 
 
20335 
  thrift_spec = (
20336 
  )
20337 
 
20338 
  def read(self, iprot):
20339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20341 
      return
20342 
    iprot.readStructBegin()
20343 
    while True:
20344 
      (fname, ftype, fid) = iprot.readFieldBegin()
20345 
      if ftype == TType.STOP:
20346 
        break
20347 
      else:
20348 
        iprot.skip(ftype)
20349 
      iprot.readFieldEnd()
20350 
    iprot.readStructEnd()
20351 
 
20352 
  def write(self, oprot):
20353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20355 
      return
20356 
    oprot.writeStructBegin('getAsinItems_args')
20357 
    oprot.writeFieldStop()
20358 
    oprot.writeStructEnd()
20359 
 
20360 
  def validate(self):
20361 
    return
20362 
 
20363 
 
20364 
  def __repr__(self):
20365 
    L = ['%s=%r' % (key, value)
20366 
      for key, value in self.__dict__.iteritems()]
20367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20368 
 
20369 
  def __eq__(self, other):
20370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20371 
 
20372 
  def __ne__(self, other):
20373 
    return not (self == other)
20374 
 
20375 
class getAsinItems_result:
20376 
  """
20377 
  Attributes:
20378 
   - success
20379 
  """
20380 
 
20381 
  thrift_spec = (
20382 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20383 
  )
20384 
 
20385 
  def __init__(self, success=None,):
20386 
    self.success = success
20387 
 
20388 
  def read(self, iprot):
20389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20391 
      return
20392 
    iprot.readStructBegin()
20393 
    while True:
20394 
      (fname, ftype, fid) = iprot.readFieldBegin()
20395 
      if ftype == TType.STOP:
20396 
        break
20397 
      if fid == 0:
20398 
        if ftype == TType.LIST:
20399 
          self.success = []
9155 kshitij.so 20400 
          (_etype442, _size439) = iprot.readListBegin()
20401 
          for _i443 in xrange(_size439):
20402 
            _elem444 = Item()
20403 
            _elem444.read(iprot)
20404 
            self.success.append(_elem444)
7291 vikram.rag 20405 
          iprot.readListEnd()
20406 
        else:
20407 
          iprot.skip(ftype)
20408 
      else:
20409 
        iprot.skip(ftype)
20410 
      iprot.readFieldEnd()
20411 
    iprot.readStructEnd()
20412 
 
20413 
  def write(self, oprot):
20414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20416 
      return
20417 
    oprot.writeStructBegin('getAsinItems_result')
20418 
    if self.success is not None:
20419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20421 
      for iter445 in self.success:
20422 
        iter445.write(oprot)
7291 vikram.rag 20423 
      oprot.writeListEnd()
20424 
      oprot.writeFieldEnd()
20425 
    oprot.writeFieldStop()
20426 
    oprot.writeStructEnd()
20427 
 
20428 
  def validate(self):
20429 
    return
20430 
 
20431 
 
20432 
  def __repr__(self):
20433 
    L = ['%s=%r' % (key, value)
20434 
      for key, value in self.__dict__.iteritems()]
20435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20436 
 
20437 
  def __eq__(self, other):
20438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20439 
 
20440 
  def __ne__(self, other):
20441 
    return not (self == other)
20442 
 
20443 
class getAllFbaListedItems_args:
20444 
 
20445 
  thrift_spec = (
20446 
  )
20447 
 
20448 
  def read(self, iprot):
20449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20451 
      return
20452 
    iprot.readStructBegin()
20453 
    while True:
20454 
      (fname, ftype, fid) = iprot.readFieldBegin()
20455 
      if ftype == TType.STOP:
20456 
        break
20457 
      else:
20458 
        iprot.skip(ftype)
20459 
      iprot.readFieldEnd()
20460 
    iprot.readStructEnd()
20461 
 
20462 
  def write(self, oprot):
20463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20465 
      return
20466 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20467 
    oprot.writeFieldStop()
20468 
    oprot.writeStructEnd()
20469 
 
20470 
  def validate(self):
20471 
    return
20472 
 
20473 
 
20474 
  def __repr__(self):
20475 
    L = ['%s=%r' % (key, value)
20476 
      for key, value in self.__dict__.iteritems()]
20477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20478 
 
20479 
  def __eq__(self, other):
20480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20481 
 
20482 
  def __ne__(self, other):
20483 
    return not (self == other)
20484 
 
20485 
class getAllFbaListedItems_result:
20486 
  """
20487 
  Attributes:
20488 
   - success
20489 
  """
20490 
 
20491 
  thrift_spec = (
20492 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20493 
  )
20494 
 
20495 
  def __init__(self, success=None,):
20496 
    self.success = success
20497 
 
20498 
  def read(self, iprot):
20499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20501 
      return
20502 
    iprot.readStructBegin()
20503 
    while True:
20504 
      (fname, ftype, fid) = iprot.readFieldBegin()
20505 
      if ftype == TType.STOP:
20506 
        break
20507 
      if fid == 0:
20508 
        if ftype == TType.LIST:
20509 
          self.success = []
9155 kshitij.so 20510 
          (_etype449, _size446) = iprot.readListBegin()
20511 
          for _i450 in xrange(_size446):
20512 
            _elem451 = Amazonlisted()
20513 
            _elem451.read(iprot)
20514 
            self.success.append(_elem451)
7291 vikram.rag 20515 
          iprot.readListEnd()
20516 
        else:
20517 
          iprot.skip(ftype)
20518 
      else:
20519 
        iprot.skip(ftype)
20520 
      iprot.readFieldEnd()
20521 
    iprot.readStructEnd()
20522 
 
20523 
  def write(self, oprot):
20524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20526 
      return
20527 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20528 
    if self.success is not None:
20529 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20530 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20531 
      for iter452 in self.success:
20532 
        iter452.write(oprot)
7291 vikram.rag 20533 
      oprot.writeListEnd()
20534 
      oprot.writeFieldEnd()
20535 
    oprot.writeFieldStop()
20536 
    oprot.writeStructEnd()
20537 
 
20538 
  def validate(self):
20539 
    return
20540 
 
20541 
 
20542 
  def __repr__(self):
20543 
    L = ['%s=%r' % (key, value)
20544 
      for key, value in self.__dict__.iteritems()]
20545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20546 
 
20547 
  def __eq__(self, other):
20548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20549 
 
20550 
  def __ne__(self, other):
20551 
    return not (self == other)
20552 
 
20553 
class getAllNonFbaListedItems_args:
20554 
 
20555 
  thrift_spec = (
20556 
  )
20557 
 
20558 
  def read(self, iprot):
20559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20561 
      return
20562 
    iprot.readStructBegin()
20563 
    while True:
20564 
      (fname, ftype, fid) = iprot.readFieldBegin()
20565 
      if ftype == TType.STOP:
20566 
        break
20567 
      else:
20568 
        iprot.skip(ftype)
20569 
      iprot.readFieldEnd()
20570 
    iprot.readStructEnd()
20571 
 
20572 
  def write(self, oprot):
20573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20575 
      return
20576 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20577 
    oprot.writeFieldStop()
20578 
    oprot.writeStructEnd()
20579 
 
20580 
  def validate(self):
20581 
    return
20582 
 
20583 
 
20584 
  def __repr__(self):
20585 
    L = ['%s=%r' % (key, value)
20586 
      for key, value in self.__dict__.iteritems()]
20587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20588 
 
20589 
  def __eq__(self, other):
20590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20591 
 
20592 
  def __ne__(self, other):
20593 
    return not (self == other)
20594 
 
20595 
class getAllNonFbaListedItems_result:
20596 
  """
20597 
  Attributes:
20598 
   - success
20599 
  """
20600 
 
20601 
  thrift_spec = (
20602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20603 
  )
20604 
 
20605 
  def __init__(self, success=None,):
20606 
    self.success = success
20607 
 
20608 
  def read(self, iprot):
20609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20611 
      return
20612 
    iprot.readStructBegin()
20613 
    while True:
20614 
      (fname, ftype, fid) = iprot.readFieldBegin()
20615 
      if ftype == TType.STOP:
20616 
        break
20617 
      if fid == 0:
20618 
        if ftype == TType.LIST:
20619 
          self.success = []
9155 kshitij.so 20620 
          (_etype456, _size453) = iprot.readListBegin()
20621 
          for _i457 in xrange(_size453):
20622 
            _elem458 = Amazonlisted()
20623 
            _elem458.read(iprot)
20624 
            self.success.append(_elem458)
7291 vikram.rag 20625 
          iprot.readListEnd()
20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      else:
20629 
        iprot.skip(ftype)
20630 
      iprot.readFieldEnd()
20631 
    iprot.readStructEnd()
20632 
 
20633 
  def write(self, oprot):
20634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20636 
      return
20637 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20638 
    if self.success is not None:
20639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20641 
      for iter459 in self.success:
20642 
        iter459.write(oprot)
7291 vikram.rag 20643 
      oprot.writeListEnd()
20644 
      oprot.writeFieldEnd()
20645 
    oprot.writeFieldStop()
20646 
    oprot.writeStructEnd()
20647 
 
20648 
  def validate(self):
20649 
    return
20650 
 
20651 
 
20652 
  def __repr__(self):
20653 
    L = ['%s=%r' % (key, value)
20654 
      for key, value in self.__dict__.iteritems()]
20655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20656 
 
20657 
  def __eq__(self, other):
20658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20659 
 
20660 
  def __ne__(self, other):
20661 
    return not (self == other)
7460 kshitij.so 20662 
 
20663 
class updateItemInventory_args:
20664 
  """
20665 
  Attributes:
20666 
   - itemId
20667 
   - holdInventory
20668 
   - defaultInventory
20669 
  """
20670 
 
20671 
  thrift_spec = (
20672 
    None, # 0
20673 
    (1, TType.I64, 'itemId', None, None, ), # 1
20674 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20675 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20676 
  )
20677 
 
20678 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20679 
    self.itemId = itemId
20680 
    self.holdInventory = holdInventory
20681 
    self.defaultInventory = defaultInventory
20682 
 
20683 
  def read(self, iprot):
20684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20686 
      return
20687 
    iprot.readStructBegin()
20688 
    while True:
20689 
      (fname, ftype, fid) = iprot.readFieldBegin()
20690 
      if ftype == TType.STOP:
20691 
        break
20692 
      if fid == 1:
20693 
        if ftype == TType.I64:
20694 
          self.itemId = iprot.readI64();
20695 
        else:
20696 
          iprot.skip(ftype)
20697 
      elif fid == 2:
20698 
        if ftype == TType.I64:
20699 
          self.holdInventory = iprot.readI64();
20700 
        else:
20701 
          iprot.skip(ftype)
20702 
      elif fid == 3:
20703 
        if ftype == TType.I64:
20704 
          self.defaultInventory = iprot.readI64();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      else:
20708 
        iprot.skip(ftype)
20709 
      iprot.readFieldEnd()
20710 
    iprot.readStructEnd()
20711 
 
20712 
  def write(self, oprot):
20713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20715 
      return
20716 
    oprot.writeStructBegin('updateItemInventory_args')
20717 
    if self.itemId is not None:
20718 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20719 
      oprot.writeI64(self.itemId)
20720 
      oprot.writeFieldEnd()
20721 
    if self.holdInventory is not None:
20722 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20723 
      oprot.writeI64(self.holdInventory)
20724 
      oprot.writeFieldEnd()
20725 
    if self.defaultInventory is not None:
20726 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20727 
      oprot.writeI64(self.defaultInventory)
20728 
      oprot.writeFieldEnd()
20729 
    oprot.writeFieldStop()
20730 
    oprot.writeStructEnd()
20731 
 
20732 
  def validate(self):
20733 
    return
20734 
 
20735 
 
20736 
  def __repr__(self):
20737 
    L = ['%s=%r' % (key, value)
20738 
      for key, value in self.__dict__.iteritems()]
20739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20740 
 
20741 
  def __eq__(self, other):
20742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20743 
 
20744 
  def __ne__(self, other):
20745 
    return not (self == other)
20746 
 
20747 
class updateItemInventory_result:
20748 
  """
20749 
  Attributes:
20750 
   - success
20751 
  """
20752 
 
20753 
  thrift_spec = (
20754 
    (0, TType.BOOL, 'success', None, None, ), # 0
20755 
  )
20756 
 
20757 
  def __init__(self, success=None,):
20758 
    self.success = success
20759 
 
20760 
  def read(self, iprot):
20761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20763 
      return
20764 
    iprot.readStructBegin()
20765 
    while True:
20766 
      (fname, ftype, fid) = iprot.readFieldBegin()
20767 
      if ftype == TType.STOP:
20768 
        break
20769 
      if fid == 0:
20770 
        if ftype == TType.BOOL:
20771 
          self.success = iprot.readBool();
20772 
        else:
20773 
          iprot.skip(ftype)
20774 
      else:
20775 
        iprot.skip(ftype)
20776 
      iprot.readFieldEnd()
20777 
    iprot.readStructEnd()
20778 
 
20779 
  def write(self, oprot):
20780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20782 
      return
20783 
    oprot.writeStructBegin('updateItemInventory_result')
20784 
    if self.success is not None:
20785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20786 
      oprot.writeBool(self.success)
20787 
      oprot.writeFieldEnd()
20788 
    oprot.writeFieldStop()
20789 
    oprot.writeStructEnd()
20790 
 
20791 
  def validate(self):
20792 
    return
20793 
 
20794 
 
20795 
  def __repr__(self):
20796 
    L = ['%s=%r' % (key, value)
20797 
      for key, value in self.__dict__.iteritems()]
20798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20799 
 
20800 
  def __eq__(self, other):
20801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20802 
 
20803 
  def __ne__(self, other):
20804 
    return not (self == other)
7770 kshitij.so 20805 
 
20806 
class updateTimestampForAmazonFeeds_args:
20807 
  """
20808 
  Attributes:
20809 
   - type
20810 
   - sku
20811 
   - timestamp
20812 
  """
20813 
 
20814 
  thrift_spec = (
20815 
    None, # 0
20816 
    (1, TType.STRING, 'type', None, None, ), # 1
20817 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20818 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20819 
  )
20820 
 
20821 
  def __init__(self, type=None, sku=None, timestamp=None,):
20822 
    self.type = type
20823 
    self.sku = sku
20824 
    self.timestamp = timestamp
20825 
 
20826 
  def read(self, iprot):
20827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20829 
      return
20830 
    iprot.readStructBegin()
20831 
    while True:
20832 
      (fname, ftype, fid) = iprot.readFieldBegin()
20833 
      if ftype == TType.STOP:
20834 
        break
20835 
      if fid == 1:
20836 
        if ftype == TType.STRING:
20837 
          self.type = iprot.readString();
20838 
        else:
20839 
          iprot.skip(ftype)
20840 
      elif fid == 2:
20841 
        if ftype == TType.LIST:
20842 
          self.sku = []
9155 kshitij.so 20843 
          (_etype463, _size460) = iprot.readListBegin()
20844 
          for _i464 in xrange(_size460):
20845 
            _elem465 = iprot.readI64();
20846 
            self.sku.append(_elem465)
7770 kshitij.so 20847 
          iprot.readListEnd()
20848 
        else:
20849 
          iprot.skip(ftype)
20850 
      elif fid == 3:
20851 
        if ftype == TType.I64:
20852 
          self.timestamp = iprot.readI64();
20853 
        else:
20854 
          iprot.skip(ftype)
20855 
      else:
20856 
        iprot.skip(ftype)
20857 
      iprot.readFieldEnd()
20858 
    iprot.readStructEnd()
20859 
 
20860 
  def write(self, oprot):
20861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20863 
      return
20864 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20865 
    if self.type is not None:
20866 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20867 
      oprot.writeString(self.type)
20868 
      oprot.writeFieldEnd()
20869 
    if self.sku is not None:
20870 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20871 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 20872 
      for iter466 in self.sku:
20873 
        oprot.writeI64(iter466)
7770 kshitij.so 20874 
      oprot.writeListEnd()
20875 
      oprot.writeFieldEnd()
20876 
    if self.timestamp is not None:
20877 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20878 
      oprot.writeI64(self.timestamp)
20879 
      oprot.writeFieldEnd()
20880 
    oprot.writeFieldStop()
20881 
    oprot.writeStructEnd()
20882 
 
20883 
  def validate(self):
20884 
    return
20885 
 
20886 
 
20887 
  def __repr__(self):
20888 
    L = ['%s=%r' % (key, value)
20889 
      for key, value in self.__dict__.iteritems()]
20890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20891 
 
20892 
  def __eq__(self, other):
20893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20894 
 
20895 
  def __ne__(self, other):
20896 
    return not (self == other)
20897 
 
20898 
class updateTimestampForAmazonFeeds_result:
20899 
  """
20900 
  Attributes:
20901 
   - success
20902 
  """
20903 
 
20904 
  thrift_spec = (
20905 
    (0, TType.BOOL, 'success', None, None, ), # 0
20906 
  )
20907 
 
20908 
  def __init__(self, success=None,):
20909 
    self.success = success
20910 
 
20911 
  def read(self, iprot):
20912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20914 
      return
20915 
    iprot.readStructBegin()
20916 
    while True:
20917 
      (fname, ftype, fid) = iprot.readFieldBegin()
20918 
      if ftype == TType.STOP:
20919 
        break
20920 
      if fid == 0:
20921 
        if ftype == TType.BOOL:
20922 
          self.success = iprot.readBool();
20923 
        else:
20924 
          iprot.skip(ftype)
20925 
      else:
20926 
        iprot.skip(ftype)
20927 
      iprot.readFieldEnd()
20928 
    iprot.readStructEnd()
20929 
 
20930 
  def write(self, oprot):
20931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20933 
      return
20934 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20935 
    if self.success is not None:
20936 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20937 
      oprot.writeBool(self.success)
20938 
      oprot.writeFieldEnd()
20939 
    oprot.writeFieldStop()
20940 
    oprot.writeStructEnd()
20941 
 
20942 
  def validate(self):
20943 
    return
20944 
 
20945 
 
20946 
  def __repr__(self):
20947 
    L = ['%s=%r' % (key, value)
20948 
      for key, value in self.__dict__.iteritems()]
20949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20950 
 
20951 
  def __eq__(self, other):
20952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20953 
 
20954 
  def __ne__(self, other):
20955 
    return not (self == other)
7897 amar.kumar 20956 
 
20957 
class getAllParentCategories_args:
20958 
 
20959 
  thrift_spec = (
20960 
  )
20961 
 
20962 
  def read(self, iprot):
20963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20965 
      return
20966 
    iprot.readStructBegin()
20967 
    while True:
20968 
      (fname, ftype, fid) = iprot.readFieldBegin()
20969 
      if ftype == TType.STOP:
20970 
        break
20971 
      else:
20972 
        iprot.skip(ftype)
20973 
      iprot.readFieldEnd()
20974 
    iprot.readStructEnd()
20975 
 
20976 
  def write(self, oprot):
20977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20979 
      return
20980 
    oprot.writeStructBegin('getAllParentCategories_args')
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
20999 
class getAllParentCategories_result:
21000 
  """
21001 
  Attributes:
21002 
   - success
21003 
  """
21004 
 
21005 
  thrift_spec = (
21006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21007 
  )
21008 
 
21009 
  def __init__(self, success=None,):
21010 
    self.success = success
21011 
 
21012 
  def read(self, iprot):
21013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21015 
      return
21016 
    iprot.readStructBegin()
21017 
    while True:
21018 
      (fname, ftype, fid) = iprot.readFieldBegin()
21019 
      if ftype == TType.STOP:
21020 
        break
21021 
      if fid == 0:
21022 
        if ftype == TType.LIST:
21023 
          self.success = []
9155 kshitij.so 21024 
          (_etype470, _size467) = iprot.readListBegin()
21025 
          for _i471 in xrange(_size467):
21026 
            _elem472 = Category()
21027 
            _elem472.read(iprot)
21028 
            self.success.append(_elem472)
7897 amar.kumar 21029 
          iprot.readListEnd()
21030 
        else:
21031 
          iprot.skip(ftype)
21032 
      else:
21033 
        iprot.skip(ftype)
21034 
      iprot.readFieldEnd()
21035 
    iprot.readStructEnd()
21036 
 
21037 
  def write(self, oprot):
21038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21040 
      return
21041 
    oprot.writeStructBegin('getAllParentCategories_result')
21042 
    if self.success is not None:
21043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21045 
      for iter473 in self.success:
21046 
        iter473.write(oprot)
7897 amar.kumar 21047 
      oprot.writeListEnd()
21048 
      oprot.writeFieldEnd()
21049 
    oprot.writeFieldStop()
21050 
    oprot.writeStructEnd()
21051 
 
21052 
  def validate(self):
21053 
    return
21054 
 
21055 
 
21056 
  def __repr__(self):
21057 
    L = ['%s=%r' % (key, value)
21058 
      for key, value in self.__dict__.iteritems()]
21059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21060 
 
21061 
  def __eq__(self, other):
21062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21063 
 
21064 
  def __ne__(self, other):
21065 
    return not (self == other)
7977 kshitij.so 21066 
 
21067 
class addPageViewEvent_args:
21068 
  """
21069 
  Attributes:
21070 
   - pageViewEvents
21071 
  """
21072 
 
21073 
  thrift_spec = (
21074 
    None, # 0
21075 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21076 
  )
21077 
 
21078 
  def __init__(self, pageViewEvents=None,):
21079 
    self.pageViewEvents = pageViewEvents
21080 
 
21081 
  def read(self, iprot):
21082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21084 
      return
21085 
    iprot.readStructBegin()
21086 
    while True:
21087 
      (fname, ftype, fid) = iprot.readFieldBegin()
21088 
      if ftype == TType.STOP:
21089 
        break
21090 
      if fid == 1:
21091 
        if ftype == TType.STRUCT:
21092 
          self.pageViewEvents = PageViewEvents()
21093 
          self.pageViewEvents.read(iprot)
21094 
        else:
21095 
          iprot.skip(ftype)
21096 
      else:
21097 
        iprot.skip(ftype)
21098 
      iprot.readFieldEnd()
21099 
    iprot.readStructEnd()
21100 
 
21101 
  def write(self, oprot):
21102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21104 
      return
21105 
    oprot.writeStructBegin('addPageViewEvent_args')
21106 
    if self.pageViewEvents is not None:
21107 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21108 
      self.pageViewEvents.write(oprot)
21109 
      oprot.writeFieldEnd()
21110 
    oprot.writeFieldStop()
21111 
    oprot.writeStructEnd()
21112 
 
21113 
  def validate(self):
21114 
    return
21115 
 
21116 
 
21117 
  def __repr__(self):
21118 
    L = ['%s=%r' % (key, value)
21119 
      for key, value in self.__dict__.iteritems()]
21120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21121 
 
21122 
  def __eq__(self, other):
21123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21124 
 
21125 
  def __ne__(self, other):
21126 
    return not (self == other)
21127 
 
21128 
class addPageViewEvent_result:
21129 
 
21130 
  thrift_spec = (
21131 
  )
21132 
 
21133 
  def read(self, iprot):
21134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21136 
      return
21137 
    iprot.readStructBegin()
21138 
    while True:
21139 
      (fname, ftype, fid) = iprot.readFieldBegin()
21140 
      if ftype == TType.STOP:
21141 
        break
21142 
      else:
21143 
        iprot.skip(ftype)
21144 
      iprot.readFieldEnd()
21145 
    iprot.readStructEnd()
21146 
 
21147 
  def write(self, oprot):
21148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21150 
      return
21151 
    oprot.writeStructBegin('addPageViewEvent_result')
21152 
    oprot.writeFieldStop()
21153 
    oprot.writeStructEnd()
21154 
 
21155 
  def validate(self):
21156 
    return
21157 
 
21158 
 
21159 
  def __repr__(self):
21160 
    L = ['%s=%r' % (key, value)
21161 
      for key, value in self.__dict__.iteritems()]
21162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21163 
 
21164 
  def __eq__(self, other):
21165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21166 
 
21167 
  def __ne__(self, other):
21168 
    return not (self == other)
21169 
 
21170 
class addCartEvent_args:
21171 
  """
21172 
  Attributes:
21173 
   - cartEvents
21174 
  """
21175 
 
21176 
  thrift_spec = (
21177 
    None, # 0
21178 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21179 
  )
21180 
 
21181 
  def __init__(self, cartEvents=None,):
21182 
    self.cartEvents = cartEvents
21183 
 
21184 
  def read(self, iprot):
21185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21187 
      return
21188 
    iprot.readStructBegin()
21189 
    while True:
21190 
      (fname, ftype, fid) = iprot.readFieldBegin()
21191 
      if ftype == TType.STOP:
21192 
        break
21193 
      if fid == 1:
21194 
        if ftype == TType.STRUCT:
21195 
          self.cartEvents = CartEvents()
21196 
          self.cartEvents.read(iprot)
21197 
        else:
21198 
          iprot.skip(ftype)
21199 
      else:
21200 
        iprot.skip(ftype)
21201 
      iprot.readFieldEnd()
21202 
    iprot.readStructEnd()
21203 
 
21204 
  def write(self, oprot):
21205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21207 
      return
21208 
    oprot.writeStructBegin('addCartEvent_args')
21209 
    if self.cartEvents is not None:
21210 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21211 
      self.cartEvents.write(oprot)
21212 
      oprot.writeFieldEnd()
21213 
    oprot.writeFieldStop()
21214 
    oprot.writeStructEnd()
21215 
 
21216 
  def validate(self):
21217 
    return
21218 
 
21219 
 
21220 
  def __repr__(self):
21221 
    L = ['%s=%r' % (key, value)
21222 
      for key, value in self.__dict__.iteritems()]
21223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21224 
 
21225 
  def __eq__(self, other):
21226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21227 
 
21228 
  def __ne__(self, other):
21229 
    return not (self == other)
21230 
 
21231 
class addCartEvent_result:
21232 
 
21233 
  thrift_spec = (
21234 
  )
21235 
 
21236 
  def read(self, iprot):
21237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21239 
      return
21240 
    iprot.readStructBegin()
21241 
    while True:
21242 
      (fname, ftype, fid) = iprot.readFieldBegin()
21243 
      if ftype == TType.STOP:
21244 
        break
21245 
      else:
21246 
        iprot.skip(ftype)
21247 
      iprot.readFieldEnd()
21248 
    iprot.readStructEnd()
21249 
 
21250 
  def write(self, oprot):
21251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21253 
      return
21254 
    oprot.writeStructBegin('addCartEvent_result')
21255 
    oprot.writeFieldStop()
21256 
    oprot.writeStructEnd()
21257 
 
21258 
  def validate(self):
21259 
    return
21260 
 
21261 
 
21262 
  def __repr__(self):
21263 
    L = ['%s=%r' % (key, value)
21264 
      for key, value in self.__dict__.iteritems()]
21265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21266 
 
21267 
  def __eq__(self, other):
21268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21269 
 
21270 
  def __ne__(self, other):
21271 
    return not (self == other)
8139 kshitij.so 21272 
 
8182 amar.kumar 21273 
class addEbayItem_args:
21274 
  """
21275 
  Attributes:
21276 
   - ebayItem
21277 
  """
21278 
 
21279 
  thrift_spec = (
21280 
    None, # 0
21281 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21282 
  )
21283 
 
21284 
  def __init__(self, ebayItem=None,):
21285 
    self.ebayItem = ebayItem
21286 
 
21287 
  def read(self, iprot):
21288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21290 
      return
21291 
    iprot.readStructBegin()
21292 
    while True:
21293 
      (fname, ftype, fid) = iprot.readFieldBegin()
21294 
      if ftype == TType.STOP:
21295 
        break
21296 
      if fid == 1:
21297 
        if ftype == TType.STRUCT:
21298 
          self.ebayItem = EbayItem()
21299 
          self.ebayItem.read(iprot)
21300 
        else:
21301 
          iprot.skip(ftype)
21302 
      else:
21303 
        iprot.skip(ftype)
21304 
      iprot.readFieldEnd()
21305 
    iprot.readStructEnd()
21306 
 
21307 
  def write(self, oprot):
21308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21310 
      return
21311 
    oprot.writeStructBegin('addEbayItem_args')
21312 
    if self.ebayItem is not None:
21313 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21314 
      self.ebayItem.write(oprot)
21315 
      oprot.writeFieldEnd()
21316 
    oprot.writeFieldStop()
21317 
    oprot.writeStructEnd()
21318 
 
21319 
  def validate(self):
21320 
    return
21321 
 
21322 
 
21323 
  def __repr__(self):
21324 
    L = ['%s=%r' % (key, value)
21325 
      for key, value in self.__dict__.iteritems()]
21326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21327 
 
21328 
  def __eq__(self, other):
21329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21330 
 
21331 
  def __ne__(self, other):
21332 
    return not (self == other)
21333 
 
21334 
class addEbayItem_result:
21335 
 
21336 
  thrift_spec = (
21337 
  )
21338 
 
21339 
  def read(self, iprot):
21340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21342 
      return
21343 
    iprot.readStructBegin()
21344 
    while True:
21345 
      (fname, ftype, fid) = iprot.readFieldBegin()
21346 
      if ftype == TType.STOP:
21347 
        break
21348 
      else:
21349 
        iprot.skip(ftype)
21350 
      iprot.readFieldEnd()
21351 
    iprot.readStructEnd()
21352 
 
21353 
  def write(self, oprot):
21354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21356 
      return
21357 
    oprot.writeStructBegin('addEbayItem_result')
21358 
    oprot.writeFieldStop()
21359 
    oprot.writeStructEnd()
21360 
 
21361 
  def validate(self):
21362 
    return
21363 
 
21364 
 
21365 
  def __repr__(self):
21366 
    L = ['%s=%r' % (key, value)
21367 
      for key, value in self.__dict__.iteritems()]
21368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21369 
 
21370 
  def __eq__(self, other):
21371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21372 
 
21373 
  def __ne__(self, other):
21374 
    return not (self == other)
21375 
 
21376 
class getEbayItem_args:
21377 
  """
21378 
  Attributes:
21379 
   - listingId
21380 
  """
21381 
 
21382 
  thrift_spec = (
21383 
    None, # 0
21384 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21385 
  )
21386 
 
21387 
  def __init__(self, listingId=None,):
21388 
    self.listingId = listingId
21389 
 
21390 
  def read(self, iprot):
21391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21393 
      return
21394 
    iprot.readStructBegin()
21395 
    while True:
21396 
      (fname, ftype, fid) = iprot.readFieldBegin()
21397 
      if ftype == TType.STOP:
21398 
        break
21399 
      if fid == 1:
21400 
        if ftype == TType.STRING:
21401 
          self.listingId = iprot.readString();
21402 
        else:
21403 
          iprot.skip(ftype)
21404 
      else:
21405 
        iprot.skip(ftype)
21406 
      iprot.readFieldEnd()
21407 
    iprot.readStructEnd()
21408 
 
21409 
  def write(self, oprot):
21410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21412 
      return
21413 
    oprot.writeStructBegin('getEbayItem_args')
21414 
    if self.listingId is not None:
21415 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21416 
      oprot.writeString(self.listingId)
21417 
      oprot.writeFieldEnd()
21418 
    oprot.writeFieldStop()
21419 
    oprot.writeStructEnd()
21420 
 
21421 
  def validate(self):
21422 
    return
21423 
 
21424 
 
21425 
  def __repr__(self):
21426 
    L = ['%s=%r' % (key, value)
21427 
      for key, value in self.__dict__.iteritems()]
21428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21429 
 
21430 
  def __eq__(self, other):
21431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21432 
 
21433 
  def __ne__(self, other):
21434 
    return not (self == other)
21435 
 
21436 
class getEbayItem_result:
21437 
  """
21438 
  Attributes:
21439 
   - success
21440 
  """
21441 
 
21442 
  thrift_spec = (
21443 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21444 
  )
21445 
 
21446 
  def __init__(self, success=None,):
21447 
    self.success = success
21448 
 
21449 
  def read(self, iprot):
21450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21452 
      return
21453 
    iprot.readStructBegin()
21454 
    while True:
21455 
      (fname, ftype, fid) = iprot.readFieldBegin()
21456 
      if ftype == TType.STOP:
21457 
        break
21458 
      if fid == 0:
21459 
        if ftype == TType.STRUCT:
21460 
          self.success = EbayItem()
21461 
          self.success.read(iprot)
21462 
        else:
21463 
          iprot.skip(ftype)
21464 
      else:
21465 
        iprot.skip(ftype)
21466 
      iprot.readFieldEnd()
21467 
    iprot.readStructEnd()
21468 
 
21469 
  def write(self, oprot):
21470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21472 
      return
21473 
    oprot.writeStructBegin('getEbayItem_result')
21474 
    if self.success is not None:
21475 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21476 
      self.success.write(oprot)
21477 
      oprot.writeFieldEnd()
21478 
    oprot.writeFieldStop()
21479 
    oprot.writeStructEnd()
21480 
 
21481 
  def validate(self):
21482 
    return
21483 
 
21484 
 
21485 
  def __repr__(self):
21486 
    L = ['%s=%r' % (key, value)
21487 
      for key, value in self.__dict__.iteritems()]
21488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21489 
 
21490 
  def __eq__(self, other):
21491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21492 
 
21493 
  def __ne__(self, other):
21494 
    return not (self == other)
21495 
 
21496 
class updateEbayItem_args:
21497 
  """
21498 
  Attributes:
21499 
   - ebayItem
21500 
  """
21501 
 
21502 
  thrift_spec = (
21503 
    None, # 0
21504 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21505 
  )
21506 
 
21507 
  def __init__(self, ebayItem=None,):
21508 
    self.ebayItem = ebayItem
21509 
 
21510 
  def read(self, iprot):
21511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21513 
      return
21514 
    iprot.readStructBegin()
21515 
    while True:
21516 
      (fname, ftype, fid) = iprot.readFieldBegin()
21517 
      if ftype == TType.STOP:
21518 
        break
21519 
      if fid == 1:
21520 
        if ftype == TType.STRUCT:
21521 
          self.ebayItem = EbayItem()
21522 
          self.ebayItem.read(iprot)
21523 
        else:
21524 
          iprot.skip(ftype)
21525 
      else:
21526 
        iprot.skip(ftype)
21527 
      iprot.readFieldEnd()
21528 
    iprot.readStructEnd()
21529 
 
21530 
  def write(self, oprot):
21531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21533 
      return
21534 
    oprot.writeStructBegin('updateEbayItem_args')
21535 
    if self.ebayItem is not None:
21536 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21537 
      self.ebayItem.write(oprot)
21538 
      oprot.writeFieldEnd()
21539 
    oprot.writeFieldStop()
21540 
    oprot.writeStructEnd()
21541 
 
21542 
  def validate(self):
21543 
    return
21544 
 
21545 
 
21546 
  def __repr__(self):
21547 
    L = ['%s=%r' % (key, value)
21548 
      for key, value in self.__dict__.iteritems()]
21549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21550 
 
21551 
  def __eq__(self, other):
21552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21553 
 
21554 
  def __ne__(self, other):
21555 
    return not (self == other)
21556 
 
21557 
class updateEbayItem_result:
21558 
 
21559 
  thrift_spec = (
21560 
  )
21561 
 
21562 
  def read(self, iprot):
21563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21565 
      return
21566 
    iprot.readStructBegin()
21567 
    while True:
21568 
      (fname, ftype, fid) = iprot.readFieldBegin()
21569 
      if ftype == TType.STOP:
21570 
        break
21571 
      else:
21572 
        iprot.skip(ftype)
21573 
      iprot.readFieldEnd()
21574 
    iprot.readStructEnd()
21575 
 
21576 
  def write(self, oprot):
21577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21579 
      return
21580 
    oprot.writeStructBegin('updateEbayItem_result')
21581 
    oprot.writeFieldStop()
21582 
    oprot.writeStructEnd()
21583 
 
21584 
  def validate(self):
21585 
    return
21586 
 
21587 
 
21588 
  def __repr__(self):
21589 
    L = ['%s=%r' % (key, value)
21590 
      for key, value in self.__dict__.iteritems()]
21591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21592 
 
21593 
  def __eq__(self, other):
21594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21595 
 
21596 
  def __ne__(self, other):
21597 
    return not (self == other)
21598 
 
8139 kshitij.so 21599 
class getAmazonListedItems_args:
21600 
  """
21601 
  Attributes:
21602 
   - offset
21603 
   - limit
21604 
  """
21605 
 
21606 
  thrift_spec = (
21607 
    None, # 0
21608 
    (1, TType.I64, 'offset', None, None, ), # 1
21609 
    (2, TType.I64, 'limit', None, None, ), # 2
21610 
  )
21611 
 
21612 
  def __init__(self, offset=None, limit=None,):
21613 
    self.offset = offset
21614 
    self.limit = limit
21615 
 
21616 
  def read(self, iprot):
21617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21619 
      return
21620 
    iprot.readStructBegin()
21621 
    while True:
21622 
      (fname, ftype, fid) = iprot.readFieldBegin()
21623 
      if ftype == TType.STOP:
21624 
        break
21625 
      if fid == 1:
21626 
        if ftype == TType.I64:
21627 
          self.offset = iprot.readI64();
21628 
        else:
21629 
          iprot.skip(ftype)
21630 
      elif fid == 2:
21631 
        if ftype == TType.I64:
21632 
          self.limit = iprot.readI64();
21633 
        else:
21634 
          iprot.skip(ftype)
21635 
      else:
21636 
        iprot.skip(ftype)
21637 
      iprot.readFieldEnd()
21638 
    iprot.readStructEnd()
21639 
 
21640 
  def write(self, oprot):
21641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21643 
      return
21644 
    oprot.writeStructBegin('getAmazonListedItems_args')
21645 
    if self.offset is not None:
21646 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21647 
      oprot.writeI64(self.offset)
21648 
      oprot.writeFieldEnd()
21649 
    if self.limit is not None:
21650 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21651 
      oprot.writeI64(self.limit)
21652 
      oprot.writeFieldEnd()
21653 
    oprot.writeFieldStop()
21654 
    oprot.writeStructEnd()
21655 
 
21656 
  def validate(self):
21657 
    return
21658 
 
21659 
 
21660 
  def __repr__(self):
21661 
    L = ['%s=%r' % (key, value)
21662 
      for key, value in self.__dict__.iteritems()]
21663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21664 
 
21665 
  def __eq__(self, other):
21666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21667 
 
21668 
  def __ne__(self, other):
21669 
    return not (self == other)
21670 
 
21671 
class getAmazonListedItems_result:
21672 
  """
21673 
  Attributes:
21674 
   - success
21675 
  """
21676 
 
21677 
  thrift_spec = (
21678 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21679 
  )
21680 
 
21681 
  def __init__(self, success=None,):
21682 
    self.success = success
21683 
 
21684 
  def read(self, iprot):
21685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21687 
      return
21688 
    iprot.readStructBegin()
21689 
    while True:
21690 
      (fname, ftype, fid) = iprot.readFieldBegin()
21691 
      if ftype == TType.STOP:
21692 
        break
21693 
      if fid == 0:
21694 
        if ftype == TType.LIST:
21695 
          self.success = []
9155 kshitij.so 21696 
          (_etype477, _size474) = iprot.readListBegin()
21697 
          for _i478 in xrange(_size474):
21698 
            _elem479 = Amazonlisted()
21699 
            _elem479.read(iprot)
21700 
            self.success.append(_elem479)
8139 kshitij.so 21701 
          iprot.readListEnd()
21702 
        else:
21703 
          iprot.skip(ftype)
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('getAmazonListedItems_result')
21714 
    if self.success is not None:
21715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21716 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21717 
      for iter480 in self.success:
21718 
        iter480.write(oprot)
8139 kshitij.so 21719 
      oprot.writeListEnd()
21720 
      oprot.writeFieldEnd()
21721 
    oprot.writeFieldStop()
21722 
    oprot.writeStructEnd()
21723 
 
21724 
  def validate(self):
21725 
    return
21726 
 
21727 
 
21728 
  def __repr__(self):
21729 
    L = ['%s=%r' % (key, value)
21730 
      for key, value in self.__dict__.iteritems()]
21731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21732 
 
21733 
  def __eq__(self, other):
21734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21735 
 
21736 
  def __ne__(self, other):
21737 
    return not (self == other)
8168 kshitij.so 21738 
 
21739 
class updateAmazonAttributesInBulk_args:
21740 
  """
21741 
  Attributes:
21742 
   - amazonlisted
21743 
  """
21744 
 
21745 
  thrift_spec = (
21746 
    None, # 0
21747 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21748 
  )
21749 
 
21750 
  def __init__(self, amazonlisted=None,):
21751 
    self.amazonlisted = amazonlisted
21752 
 
21753 
  def read(self, iprot):
21754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21756 
      return
21757 
    iprot.readStructBegin()
21758 
    while True:
21759 
      (fname, ftype, fid) = iprot.readFieldBegin()
21760 
      if ftype == TType.STOP:
21761 
        break
21762 
      if fid == 1:
21763 
        if ftype == TType.MAP:
21764 
          self.amazonlisted = {}
9155 kshitij.so 21765 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
21766 
          for _i485 in xrange(_size481):
21767 
            _key486 = iprot.readI64();
21768 
            _val487 = Amazonlisted()
21769 
            _val487.read(iprot)
21770 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 21771 
          iprot.readMapEnd()
21772 
        else:
21773 
          iprot.skip(ftype)
21774 
      else:
21775 
        iprot.skip(ftype)
21776 
      iprot.readFieldEnd()
21777 
    iprot.readStructEnd()
21778 
 
21779 
  def write(self, oprot):
21780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21782 
      return
21783 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
21784 
    if self.amazonlisted is not None:
21785 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21786 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 21787 
      for kiter488,viter489 in self.amazonlisted.items():
21788 
        oprot.writeI64(kiter488)
21789 
        viter489.write(oprot)
8168 kshitij.so 21790 
      oprot.writeMapEnd()
21791 
      oprot.writeFieldEnd()
21792 
    oprot.writeFieldStop()
21793 
    oprot.writeStructEnd()
21794 
 
21795 
  def validate(self):
21796 
    return
21797 
 
21798 
 
21799 
  def __repr__(self):
21800 
    L = ['%s=%r' % (key, value)
21801 
      for key, value in self.__dict__.iteritems()]
21802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21803 
 
21804 
  def __eq__(self, other):
21805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21806 
 
21807 
  def __ne__(self, other):
21808 
    return not (self == other)
21809 
 
21810 
class updateAmazonAttributesInBulk_result:
21811 
  """
21812 
  Attributes:
21813 
   - success
21814 
  """
21815 
 
21816 
  thrift_spec = (
21817 
    (0, TType.BOOL, 'success', None, None, ), # 0
21818 
  )
21819 
 
21820 
  def __init__(self, success=None,):
21821 
    self.success = success
21822 
 
21823 
  def read(self, iprot):
21824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21826 
      return
21827 
    iprot.readStructBegin()
21828 
    while True:
21829 
      (fname, ftype, fid) = iprot.readFieldBegin()
21830 
      if ftype == TType.STOP:
21831 
        break
21832 
      if fid == 0:
21833 
        if ftype == TType.BOOL:
21834 
          self.success = iprot.readBool();
21835 
        else:
21836 
          iprot.skip(ftype)
21837 
      else:
21838 
        iprot.skip(ftype)
21839 
      iprot.readFieldEnd()
21840 
    iprot.readStructEnd()
21841 
 
21842 
  def write(self, oprot):
21843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21845 
      return
21846 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21847 
    if self.success is not None:
21848 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21849 
      oprot.writeBool(self.success)
21850 
      oprot.writeFieldEnd()
21851 
    oprot.writeFieldStop()
21852 
    oprot.writeStructEnd()
21853 
 
21854 
  def validate(self):
21855 
    return
21856 
 
21857 
 
21858 
  def __repr__(self):
21859 
    L = ['%s=%r' % (key, value)
21860 
      for key, value in self.__dict__.iteritems()]
21861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21862 
 
21863 
  def __eq__(self, other):
21864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21865 
 
21866 
  def __ne__(self, other):
21867 
    return not (self == other)
8379 vikram.rag 21868 
 
21869 
class getAllItemstoListOnFba_args:
21870 
 
21871 
  thrift_spec = (
21872 
  )
21873 
 
21874 
  def read(self, iprot):
21875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21877 
      return
21878 
    iprot.readStructBegin()
21879 
    while True:
21880 
      (fname, ftype, fid) = iprot.readFieldBegin()
21881 
      if ftype == TType.STOP:
21882 
        break
21883 
      else:
21884 
        iprot.skip(ftype)
21885 
      iprot.readFieldEnd()
21886 
    iprot.readStructEnd()
21887 
 
21888 
  def write(self, oprot):
21889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21891 
      return
21892 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21893 
    oprot.writeFieldStop()
21894 
    oprot.writeStructEnd()
21895 
 
21896 
  def validate(self):
21897 
    return
21898 
 
21899 
 
21900 
  def __repr__(self):
21901 
    L = ['%s=%r' % (key, value)
21902 
      for key, value in self.__dict__.iteritems()]
21903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21904 
 
21905 
  def __eq__(self, other):
21906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21907 
 
21908 
  def __ne__(self, other):
21909 
    return not (self == other)
21910 
 
21911 
class getAllItemstoListOnFba_result:
21912 
  """
21913 
  Attributes:
21914 
   - success
21915 
  """
21916 
 
21917 
  thrift_spec = (
21918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21919 
  )
21920 
 
21921 
  def __init__(self, success=None,):
21922 
    self.success = success
21923 
 
21924 
  def read(self, iprot):
21925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21927 
      return
21928 
    iprot.readStructBegin()
21929 
    while True:
21930 
      (fname, ftype, fid) = iprot.readFieldBegin()
21931 
      if ftype == TType.STOP:
21932 
        break
21933 
      if fid == 0:
21934 
        if ftype == TType.LIST:
21935 
          self.success = []
9155 kshitij.so 21936 
          (_etype493, _size490) = iprot.readListBegin()
21937 
          for _i494 in xrange(_size490):
21938 
            _elem495 = Amazonlisted()
21939 
            _elem495.read(iprot)
21940 
            self.success.append(_elem495)
8379 vikram.rag 21941 
          iprot.readListEnd()
21942 
        else:
21943 
          iprot.skip(ftype)
21944 
      else:
21945 
        iprot.skip(ftype)
21946 
      iprot.readFieldEnd()
21947 
    iprot.readStructEnd()
21948 
 
21949 
  def write(self, oprot):
21950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21952 
      return
21953 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
21954 
    if self.success is not None:
21955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21957 
      for iter496 in self.success:
21958 
        iter496.write(oprot)
8379 vikram.rag 21959 
      oprot.writeListEnd()
21960 
      oprot.writeFieldEnd()
21961 
    oprot.writeFieldStop()
21962 
    oprot.writeStructEnd()
21963 
 
21964 
  def validate(self):
21965 
    return
21966 
 
21967 
 
21968 
  def __repr__(self):
21969 
    L = ['%s=%r' % (key, value)
21970 
      for key, value in self.__dict__.iteritems()]
21971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21972 
 
21973 
  def __eq__(self, other):
21974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21975 
 
21976 
  def __ne__(self, other):
21977 
    return not (self == other)
21978 
 
21979 
class getAllItemstoListOnNonFba_args:
21980 
 
21981 
  thrift_spec = (
21982 
  )
21983 
 
21984 
  def read(self, iprot):
21985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21987 
      return
21988 
    iprot.readStructBegin()
21989 
    while True:
21990 
      (fname, ftype, fid) = iprot.readFieldBegin()
21991 
      if ftype == TType.STOP:
21992 
        break
21993 
      else:
21994 
        iprot.skip(ftype)
21995 
      iprot.readFieldEnd()
21996 
    iprot.readStructEnd()
21997 
 
21998 
  def write(self, oprot):
21999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22001 
      return
22002 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22003 
    oprot.writeFieldStop()
22004 
    oprot.writeStructEnd()
22005 
 
22006 
  def validate(self):
22007 
    return
22008 
 
22009 
 
22010 
  def __repr__(self):
22011 
    L = ['%s=%r' % (key, value)
22012 
      for key, value in self.__dict__.iteritems()]
22013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22014 
 
22015 
  def __eq__(self, other):
22016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22017 
 
22018 
  def __ne__(self, other):
22019 
    return not (self == other)
22020 
 
22021 
class getAllItemstoListOnNonFba_result:
22022 
  """
22023 
  Attributes:
22024 
   - success
22025 
  """
22026 
 
22027 
  thrift_spec = (
22028 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22029 
  )
22030 
 
22031 
  def __init__(self, success=None,):
22032 
    self.success = success
22033 
 
22034 
  def read(self, iprot):
22035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22037 
      return
22038 
    iprot.readStructBegin()
22039 
    while True:
22040 
      (fname, ftype, fid) = iprot.readFieldBegin()
22041 
      if ftype == TType.STOP:
22042 
        break
22043 
      if fid == 0:
22044 
        if ftype == TType.LIST:
22045 
          self.success = []
9155 kshitij.so 22046 
          (_etype500, _size497) = iprot.readListBegin()
22047 
          for _i501 in xrange(_size497):
22048 
            _elem502 = Amazonlisted()
22049 
            _elem502.read(iprot)
22050 
            self.success.append(_elem502)
8379 vikram.rag 22051 
          iprot.readListEnd()
22052 
        else:
22053 
          iprot.skip(ftype)
22054 
      else:
22055 
        iprot.skip(ftype)
22056 
      iprot.readFieldEnd()
22057 
    iprot.readStructEnd()
22058 
 
22059 
  def write(self, oprot):
22060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22062 
      return
22063 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22064 
    if self.success is not None:
22065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22067 
      for iter503 in self.success:
22068 
        iter503.write(oprot)
8379 vikram.rag 22069 
      oprot.writeListEnd()
22070 
      oprot.writeFieldEnd()
22071 
    oprot.writeFieldStop()
22072 
    oprot.writeStructEnd()
22073 
 
22074 
  def validate(self):
22075 
    return
22076 
 
22077 
 
22078 
  def __repr__(self):
22079 
    L = ['%s=%r' % (key, value)
22080 
      for key, value in self.__dict__.iteritems()]
22081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22082 
 
22083 
  def __eq__(self, other):
22084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22085 
 
22086 
  def __ne__(self, other):
22087 
    return not (self == other)
8616 vikram.rag 22088 
 
9242 kshitij.so 22089 
class updateAsin_args:
22090 
  """
22091 
  Attributes:
22092 
   - item
22093 
  """
8616 vikram.rag 22094 
 
22095 
  thrift_spec = (
9242 kshitij.so 22096 
    None, # 0
22097 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22098 
  )
22099 
 
9242 kshitij.so 22100 
  def __init__(self, item=None,):
22101 
    self.item = item
22102 
 
8616 vikram.rag 22103 
  def read(self, iprot):
22104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22106 
      return
22107 
    iprot.readStructBegin()
22108 
    while True:
22109 
      (fname, ftype, fid) = iprot.readFieldBegin()
22110 
      if ftype == TType.STOP:
22111 
        break
9242 kshitij.so 22112 
      if fid == 1:
22113 
        if ftype == TType.MAP:
22114 
          self.item = {}
22115 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22116 
          for _i508 in xrange(_size504):
22117 
            _key509 = iprot.readI64();
22118 
            _val510 = Item()
22119 
            _val510.read(iprot)
22120 
            self.item[_key509] = _val510
22121 
          iprot.readMapEnd()
22122 
        else:
22123 
          iprot.skip(ftype)
8616 vikram.rag 22124 
      else:
22125 
        iprot.skip(ftype)
22126 
      iprot.readFieldEnd()
22127 
    iprot.readStructEnd()
22128 
 
22129 
  def write(self, oprot):
22130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22132 
      return
9242 kshitij.so 22133 
    oprot.writeStructBegin('updateAsin_args')
22134 
    if self.item is not None:
22135 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22136 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22137 
      for kiter511,viter512 in self.item.items():
22138 
        oprot.writeI64(kiter511)
22139 
        viter512.write(oprot)
22140 
      oprot.writeMapEnd()
22141 
      oprot.writeFieldEnd()
8616 vikram.rag 22142 
    oprot.writeFieldStop()
22143 
    oprot.writeStructEnd()
22144 
 
22145 
  def validate(self):
22146 
    return
22147 
 
22148 
 
22149 
  def __repr__(self):
22150 
    L = ['%s=%r' % (key, value)
22151 
      for key, value in self.__dict__.iteritems()]
22152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22153 
 
22154 
  def __eq__(self, other):
22155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22156 
 
22157 
  def __ne__(self, other):
22158 
    return not (self == other)
22159 
 
9242 kshitij.so 22160 
class updateAsin_result:
8616 vikram.rag 22161 
 
22162 
  thrift_spec = (
22163 
  )
22164 
 
22165 
  def read(self, iprot):
22166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22168 
      return
22169 
    iprot.readStructBegin()
22170 
    while True:
22171 
      (fname, ftype, fid) = iprot.readFieldBegin()
22172 
      if ftype == TType.STOP:
22173 
        break
22174 
      else:
22175 
        iprot.skip(ftype)
22176 
      iprot.readFieldEnd()
22177 
    iprot.readStructEnd()
22178 
 
22179 
  def write(self, oprot):
22180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22182 
      return
9242 kshitij.so 22183 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22184 
    oprot.writeFieldStop()
22185 
    oprot.writeStructEnd()
22186 
 
22187 
  def validate(self):
22188 
    return
22189 
 
22190 
 
22191 
  def __repr__(self):
22192 
    L = ['%s=%r' % (key, value)
22193 
      for key, value in self.__dict__.iteritems()]
22194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22195 
 
22196 
  def __eq__(self, other):
22197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22198 
 
22199 
  def __ne__(self, other):
22200 
    return not (self == other)
8619 kshitij.so 22201 
 
9242 kshitij.so 22202 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22203 
  """
22204 
  Attributes:
9242 kshitij.so 22205 
   - snapdealitem
8619 kshitij.so 22206 
  """
22207 
 
9242 kshitij.so 22208 
  thrift_spec = None
22209 
  def __init__(self, snapdealitem=None,):
22210 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22211 
 
22212 
  def read(self, iprot):
22213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22215 
      return
22216 
    iprot.readStructBegin()
22217 
    while True:
22218 
      (fname, ftype, fid) = iprot.readFieldBegin()
22219 
      if ftype == TType.STOP:
22220 
        break
9242 kshitij.so 22221 
      if fid == -1:
22222 
        if ftype == TType.STRUCT:
22223 
          self.snapdealitem = SnapdealItem()
22224 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22225 
        else:
22226 
          iprot.skip(ftype)
22227 
      else:
22228 
        iprot.skip(ftype)
22229 
      iprot.readFieldEnd()
22230 
    iprot.readStructEnd()
22231 
 
22232 
  def write(self, oprot):
22233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22235 
      return
9242 kshitij.so 22236 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22237 
    if self.snapdealitem is not None:
22238 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22239 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22240 
      oprot.writeFieldEnd()
22241 
    oprot.writeFieldStop()
22242 
    oprot.writeStructEnd()
22243 
 
22244 
  def validate(self):
22245 
    return
22246 
 
22247 
 
22248 
  def __repr__(self):
22249 
    L = ['%s=%r' % (key, value)
22250 
      for key, value in self.__dict__.iteritems()]
22251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22252 
 
22253 
  def __eq__(self, other):
22254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22255 
 
22256 
  def __ne__(self, other):
22257 
    return not (self == other)
22258 
 
9242 kshitij.so 22259 
class addOrUpdateSnapdealItem_result:
22260 
  """
22261 
  Attributes:
22262 
   - success
22263 
  """
8619 kshitij.so 22264 
 
22265 
  thrift_spec = (
9242 kshitij.so 22266 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22267 
  )
22268 
 
9242 kshitij.so 22269 
  def __init__(self, success=None,):
22270 
    self.success = success
22271 
 
8619 kshitij.so 22272 
  def read(self, iprot):
22273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22275 
      return
22276 
    iprot.readStructBegin()
22277 
    while True:
22278 
      (fname, ftype, fid) = iprot.readFieldBegin()
22279 
      if ftype == TType.STOP:
22280 
        break
9242 kshitij.so 22281 
      if fid == 0:
22282 
        if ftype == TType.BOOL:
22283 
          self.success = iprot.readBool();
22284 
        else:
22285 
          iprot.skip(ftype)
8619 kshitij.so 22286 
      else:
22287 
        iprot.skip(ftype)
22288 
      iprot.readFieldEnd()
22289 
    iprot.readStructEnd()
22290 
 
22291 
  def write(self, oprot):
22292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22294 
      return
9242 kshitij.so 22295 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22296 
    if self.success is not None:
22297 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22298 
      oprot.writeBool(self.success)
22299 
      oprot.writeFieldEnd()
8619 kshitij.so 22300 
    oprot.writeFieldStop()
22301 
    oprot.writeStructEnd()
22302 
 
22303 
  def validate(self):
22304 
    return
22305 
 
22306 
 
22307 
  def __repr__(self):
22308 
    L = ['%s=%r' % (key, value)
22309 
      for key, value in self.__dict__.iteritems()]
22310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22311 
 
22312 
  def __eq__(self, other):
22313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22314 
 
22315 
  def __ne__(self, other):
22316 
    return not (self == other)
8739 vikram.rag 22317 
 
9242 kshitij.so 22318 
class getSnapdealItem_args:
8739 vikram.rag 22319 
  """
22320 
  Attributes:
9242 kshitij.so 22321 
   - item_id
8739 vikram.rag 22322 
  """
22323 
 
9242 kshitij.so 22324 
  thrift_spec = (
22325 
    None, # 0
22326 
    (1, TType.I64, 'item_id', None, None, ), # 1
22327 
  )
8739 vikram.rag 22328 
 
9242 kshitij.so 22329 
  def __init__(self, item_id=None,):
22330 
    self.item_id = item_id
22331 
 
8739 vikram.rag 22332 
  def read(self, iprot):
22333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22335 
      return
22336 
    iprot.readStructBegin()
22337 
    while True:
22338 
      (fname, ftype, fid) = iprot.readFieldBegin()
22339 
      if ftype == TType.STOP:
22340 
        break
9242 kshitij.so 22341 
      if fid == 1:
22342 
        if ftype == TType.I64:
22343 
          self.item_id = iprot.readI64();
8739 vikram.rag 22344 
        else:
22345 
          iprot.skip(ftype)
22346 
      else:
22347 
        iprot.skip(ftype)
22348 
      iprot.readFieldEnd()
22349 
    iprot.readStructEnd()
22350 
 
22351 
  def write(self, oprot):
22352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22354 
      return
9242 kshitij.so 22355 
    oprot.writeStructBegin('getSnapdealItem_args')
22356 
    if self.item_id is not None:
22357 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22358 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22359 
      oprot.writeFieldEnd()
22360 
    oprot.writeFieldStop()
22361 
    oprot.writeStructEnd()
22362 
 
22363 
  def validate(self):
22364 
    return
22365 
 
22366 
 
22367 
  def __repr__(self):
22368 
    L = ['%s=%r' % (key, value)
22369 
      for key, value in self.__dict__.iteritems()]
22370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22371 
 
22372 
  def __eq__(self, other):
22373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22374 
 
22375 
  def __ne__(self, other):
22376 
    return not (self == other)
22377 
 
9242 kshitij.so 22378 
class getSnapdealItem_result:
8739 vikram.rag 22379 
  """
22380 
  Attributes:
22381 
   - success
22382 
  """
22383 
 
22384 
  thrift_spec = (
9242 kshitij.so 22385 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 22386 
  )
22387 
 
22388 
  def __init__(self, success=None,):
22389 
    self.success = success
22390 
 
22391 
  def read(self, iprot):
22392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22394 
      return
22395 
    iprot.readStructBegin()
22396 
    while True:
22397 
      (fname, ftype, fid) = iprot.readFieldBegin()
22398 
      if ftype == TType.STOP:
22399 
        break
22400 
      if fid == 0:
9242 kshitij.so 22401 
        if ftype == TType.STRUCT:
22402 
          self.success = SnapdealItem()
22403 
          self.success.read(iprot)
8739 vikram.rag 22404 
        else:
22405 
          iprot.skip(ftype)
22406 
      else:
22407 
        iprot.skip(ftype)
22408 
      iprot.readFieldEnd()
22409 
    iprot.readStructEnd()
22410 
 
22411 
  def write(self, oprot):
22412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22414 
      return
9242 kshitij.so 22415 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 22416 
    if self.success is not None:
9242 kshitij.so 22417 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22418 
      self.success.write(oprot)
8739 vikram.rag 22419 
      oprot.writeFieldEnd()
22420 
    oprot.writeFieldStop()
22421 
    oprot.writeStructEnd()
22422 
 
22423 
  def validate(self):
22424 
    return
22425 
 
22426 
 
22427 
  def __repr__(self):
22428 
    L = ['%s=%r' % (key, value)
22429 
      for key, value in self.__dict__.iteritems()]
22430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22431 
 
22432 
  def __eq__(self, other):
22433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22434 
 
22435 
  def __ne__(self, other):
22436 
    return not (self == other)
22437 
 
9242 kshitij.so 22438 
class getSnapdealItemDetails_args:
8739 vikram.rag 22439 
  """
22440 
  Attributes:
22441 
   - item_id
22442 
  """
22443 
 
22444 
  thrift_spec = (
22445 
    None, # 0
22446 
    (1, TType.I64, 'item_id', None, None, ), # 1
22447 
  )
22448 
 
22449 
  def __init__(self, item_id=None,):
22450 
    self.item_id = item_id
22451 
 
22452 
  def read(self, iprot):
22453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22455 
      return
22456 
    iprot.readStructBegin()
22457 
    while True:
22458 
      (fname, ftype, fid) = iprot.readFieldBegin()
22459 
      if ftype == TType.STOP:
22460 
        break
22461 
      if fid == 1:
22462 
        if ftype == TType.I64:
22463 
          self.item_id = iprot.readI64();
22464 
        else:
22465 
          iprot.skip(ftype)
22466 
      else:
22467 
        iprot.skip(ftype)
22468 
      iprot.readFieldEnd()
22469 
    iprot.readStructEnd()
22470 
 
22471 
  def write(self, oprot):
22472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22474 
      return
9242 kshitij.so 22475 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 22476 
    if self.item_id is not None:
22477 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22478 
      oprot.writeI64(self.item_id)
22479 
      oprot.writeFieldEnd()
22480 
    oprot.writeFieldStop()
22481 
    oprot.writeStructEnd()
22482 
 
22483 
  def validate(self):
22484 
    return
22485 
 
22486 
 
22487 
  def __repr__(self):
22488 
    L = ['%s=%r' % (key, value)
22489 
      for key, value in self.__dict__.iteritems()]
22490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22491 
 
22492 
  def __eq__(self, other):
22493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22494 
 
22495 
  def __ne__(self, other):
22496 
    return not (self == other)
22497 
 
9242 kshitij.so 22498 
class getSnapdealItemDetails_result:
8739 vikram.rag 22499 
  """
22500 
  Attributes:
22501 
   - success
22502 
  """
22503 
 
22504 
  thrift_spec = (
9242 kshitij.so 22505 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 22506 
  )
22507 
 
22508 
  def __init__(self, success=None,):
22509 
    self.success = success
22510 
 
22511 
  def read(self, iprot):
22512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22514 
      return
22515 
    iprot.readStructBegin()
22516 
    while True:
22517 
      (fname, ftype, fid) = iprot.readFieldBegin()
22518 
      if ftype == TType.STOP:
22519 
        break
22520 
      if fid == 0:
22521 
        if ftype == TType.STRUCT:
9242 kshitij.so 22522 
          self.success = SnapdealItemDetails()
8739 vikram.rag 22523 
          self.success.read(iprot)
22524 
        else:
22525 
          iprot.skip(ftype)
22526 
      else:
22527 
        iprot.skip(ftype)
22528 
      iprot.readFieldEnd()
22529 
    iprot.readStructEnd()
22530 
 
22531 
  def write(self, oprot):
22532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22534 
      return
9242 kshitij.so 22535 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 22536 
    if self.success is not None:
22537 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22538 
      self.success.write(oprot)
22539 
      oprot.writeFieldEnd()
22540 
    oprot.writeFieldStop()
22541 
    oprot.writeStructEnd()
22542 
 
22543 
  def validate(self):
22544 
    return
22545 
 
22546 
 
22547 
  def __repr__(self):
22548 
    L = ['%s=%r' % (key, value)
22549 
      for key, value in self.__dict__.iteritems()]
22550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22551 
 
22552 
  def __eq__(self, other):
22553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22554 
 
22555 
  def __ne__(self, other):
22556 
    return not (self == other)
22557 
 
22558 
class getAllSnapdealItems_args:
22559 
 
22560 
  thrift_spec = (
22561 
  )
22562 
 
22563 
  def read(self, iprot):
22564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22566 
      return
22567 
    iprot.readStructBegin()
22568 
    while True:
22569 
      (fname, ftype, fid) = iprot.readFieldBegin()
22570 
      if ftype == TType.STOP:
22571 
        break
22572 
      else:
22573 
        iprot.skip(ftype)
22574 
      iprot.readFieldEnd()
22575 
    iprot.readStructEnd()
22576 
 
22577 
  def write(self, oprot):
22578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22580 
      return
22581 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22582 
    oprot.writeFieldStop()
22583 
    oprot.writeStructEnd()
22584 
 
22585 
  def validate(self):
22586 
    return
22587 
 
22588 
 
22589 
  def __repr__(self):
22590 
    L = ['%s=%r' % (key, value)
22591 
      for key, value in self.__dict__.iteritems()]
22592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22593 
 
22594 
  def __eq__(self, other):
22595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22596 
 
22597 
  def __ne__(self, other):
22598 
    return not (self == other)
22599 
 
22600 
class getAllSnapdealItems_result:
22601 
  """
22602 
  Attributes:
22603 
   - success
22604 
  """
22605 
 
22606 
  thrift_spec = (
9242 kshitij.so 22607 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 22608 
  )
22609 
 
22610 
  def __init__(self, success=None,):
22611 
    self.success = success
22612 
 
22613 
  def read(self, iprot):
22614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22616 
      return
22617 
    iprot.readStructBegin()
22618 
    while True:
22619 
      (fname, ftype, fid) = iprot.readFieldBegin()
22620 
      if ftype == TType.STOP:
22621 
        break
22622 
      if fid == 0:
22623 
        if ftype == TType.LIST:
22624 
          self.success = []
9242 kshitij.so 22625 
          (_etype516, _size513) = iprot.readListBegin()
22626 
          for _i517 in xrange(_size513):
22627 
            _elem518 = SnapdealItemDetails()
22628 
            _elem518.read(iprot)
22629 
            self.success.append(_elem518)
22630 
          iprot.readListEnd()
22631 
        else:
22632 
          iprot.skip(ftype)
22633 
      else:
22634 
        iprot.skip(ftype)
22635 
      iprot.readFieldEnd()
22636 
    iprot.readStructEnd()
22637 
 
22638 
  def write(self, oprot):
22639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22641 
      return
22642 
    oprot.writeStructBegin('getAllSnapdealItems_result')
22643 
    if self.success is not None:
22644 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22645 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22646 
      for iter519 in self.success:
22647 
        iter519.write(oprot)
22648 
      oprot.writeListEnd()
22649 
      oprot.writeFieldEnd()
22650 
    oprot.writeFieldStop()
22651 
    oprot.writeStructEnd()
22652 
 
22653 
  def validate(self):
22654 
    return
22655 
 
22656 
 
22657 
  def __repr__(self):
22658 
    L = ['%s=%r' % (key, value)
22659 
      for key, value in self.__dict__.iteritems()]
22660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22661 
 
22662 
  def __eq__(self, other):
22663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22664 
 
22665 
  def __ne__(self, other):
22666 
    return not (self == other)
22667 
 
22668 
class getSnapdealItems_args:
22669 
  """
22670 
  Attributes:
22671 
   - offset
22672 
   - limit
22673 
  """
22674 
 
22675 
  thrift_spec = (
22676 
    None, # 0
22677 
    (1, TType.I64, 'offset', None, None, ), # 1
22678 
    (2, TType.I64, 'limit', None, None, ), # 2
22679 
  )
22680 
 
22681 
  def __init__(self, offset=None, limit=None,):
22682 
    self.offset = offset
22683 
    self.limit = limit
22684 
 
22685 
  def read(self, iprot):
22686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22688 
      return
22689 
    iprot.readStructBegin()
22690 
    while True:
22691 
      (fname, ftype, fid) = iprot.readFieldBegin()
22692 
      if ftype == TType.STOP:
22693 
        break
22694 
      if fid == 1:
22695 
        if ftype == TType.I64:
22696 
          self.offset = iprot.readI64();
22697 
        else:
22698 
          iprot.skip(ftype)
22699 
      elif fid == 2:
22700 
        if ftype == TType.I64:
22701 
          self.limit = iprot.readI64();
22702 
        else:
22703 
          iprot.skip(ftype)
22704 
      else:
22705 
        iprot.skip(ftype)
22706 
      iprot.readFieldEnd()
22707 
    iprot.readStructEnd()
22708 
 
22709 
  def write(self, oprot):
22710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22712 
      return
22713 
    oprot.writeStructBegin('getSnapdealItems_args')
22714 
    if self.offset is not None:
22715 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22716 
      oprot.writeI64(self.offset)
22717 
      oprot.writeFieldEnd()
22718 
    if self.limit is not None:
22719 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22720 
      oprot.writeI64(self.limit)
22721 
      oprot.writeFieldEnd()
22722 
    oprot.writeFieldStop()
22723 
    oprot.writeStructEnd()
22724 
 
22725 
  def validate(self):
22726 
    return
22727 
 
22728 
 
22729 
  def __repr__(self):
22730 
    L = ['%s=%r' % (key, value)
22731 
      for key, value in self.__dict__.iteritems()]
22732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22733 
 
22734 
  def __eq__(self, other):
22735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22736 
 
22737 
  def __ne__(self, other):
22738 
    return not (self == other)
22739 
 
22740 
class getSnapdealItems_result:
22741 
  """
22742 
  Attributes:
22743 
   - success
22744 
  """
22745 
 
22746 
  thrift_spec = (
22747 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22748 
  )
22749 
 
22750 
  def __init__(self, success=None,):
22751 
    self.success = success
22752 
 
22753 
  def read(self, iprot):
22754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22756 
      return
22757 
    iprot.readStructBegin()
22758 
    while True:
22759 
      (fname, ftype, fid) = iprot.readFieldBegin()
22760 
      if ftype == TType.STOP:
22761 
        break
22762 
      if fid == 0:
22763 
        if ftype == TType.LIST:
22764 
          self.success = []
9155 kshitij.so 22765 
          (_etype523, _size520) = iprot.readListBegin()
22766 
          for _i524 in xrange(_size520):
9242 kshitij.so 22767 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 22768 
            _elem525.read(iprot)
22769 
            self.success.append(_elem525)
8739 vikram.rag 22770 
          iprot.readListEnd()
22771 
        else:
22772 
          iprot.skip(ftype)
22773 
      else:
22774 
        iprot.skip(ftype)
22775 
      iprot.readFieldEnd()
22776 
    iprot.readStructEnd()
22777 
 
22778 
  def write(self, oprot):
22779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22781 
      return
9242 kshitij.so 22782 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 22783 
    if self.success is not None:
22784 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22785 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22786 
      for iter526 in self.success:
22787 
        iter526.write(oprot)
8739 vikram.rag 22788 
      oprot.writeListEnd()
22789 
      oprot.writeFieldEnd()
22790 
    oprot.writeFieldStop()
22791 
    oprot.writeStructEnd()
22792 
 
22793 
  def validate(self):
22794 
    return
22795 
 
22796 
 
22797 
  def __repr__(self):
22798 
    L = ['%s=%r' % (key, value)
22799 
      for key, value in self.__dict__.iteritems()]
22800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22801 
 
22802 
  def __eq__(self, other):
22803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22804 
 
22805 
  def __ne__(self, other):
22806 
    return not (self == other)
9242 kshitij.so 22807 
 
22808 
class searchSnapdealItems_args:
22809 
  """
22810 
  Attributes:
22811 
   - searchTerm
22812 
   - offset
22813 
   - limit
22814 
  """
22815 
 
22816 
  thrift_spec = (
22817 
    None, # 0
22818 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
22819 
    (2, TType.I64, 'offset', None, None, ), # 2
22820 
    (3, TType.I64, 'limit', None, None, ), # 3
22821 
  )
22822 
 
22823 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
22824 
    self.searchTerm = searchTerm
22825 
    self.offset = offset
22826 
    self.limit = limit
22827 
 
22828 
  def read(self, iprot):
22829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22831 
      return
22832 
    iprot.readStructBegin()
22833 
    while True:
22834 
      (fname, ftype, fid) = iprot.readFieldBegin()
22835 
      if ftype == TType.STOP:
22836 
        break
22837 
      if fid == 1:
22838 
        if ftype == TType.LIST:
22839 
          self.searchTerm = []
22840 
          (_etype530, _size527) = iprot.readListBegin()
22841 
          for _i531 in xrange(_size527):
22842 
            _elem532 = iprot.readString();
22843 
            self.searchTerm.append(_elem532)
22844 
          iprot.readListEnd()
22845 
        else:
22846 
          iprot.skip(ftype)
22847 
      elif fid == 2:
22848 
        if ftype == TType.I64:
22849 
          self.offset = iprot.readI64();
22850 
        else:
22851 
          iprot.skip(ftype)
22852 
      elif fid == 3:
22853 
        if ftype == TType.I64:
22854 
          self.limit = iprot.readI64();
22855 
        else:
22856 
          iprot.skip(ftype)
22857 
      else:
22858 
        iprot.skip(ftype)
22859 
      iprot.readFieldEnd()
22860 
    iprot.readStructEnd()
22861 
 
22862 
  def write(self, oprot):
22863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22865 
      return
22866 
    oprot.writeStructBegin('searchSnapdealItems_args')
22867 
    if self.searchTerm is not None:
22868 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
22869 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
22870 
      for iter533 in self.searchTerm:
22871 
        oprot.writeString(iter533)
22872 
      oprot.writeListEnd()
22873 
      oprot.writeFieldEnd()
22874 
    if self.offset is not None:
22875 
      oprot.writeFieldBegin('offset', TType.I64, 2)
22876 
      oprot.writeI64(self.offset)
22877 
      oprot.writeFieldEnd()
22878 
    if self.limit is not None:
22879 
      oprot.writeFieldBegin('limit', TType.I64, 3)
22880 
      oprot.writeI64(self.limit)
22881 
      oprot.writeFieldEnd()
22882 
    oprot.writeFieldStop()
22883 
    oprot.writeStructEnd()
22884 
 
22885 
  def validate(self):
22886 
    return
22887 
 
22888 
 
22889 
  def __repr__(self):
22890 
    L = ['%s=%r' % (key, value)
22891 
      for key, value in self.__dict__.iteritems()]
22892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22893 
 
22894 
  def __eq__(self, other):
22895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22896 
 
22897 
  def __ne__(self, other):
22898 
    return not (self == other)
22899 
 
22900 
class searchSnapdealItems_result:
22901 
  """
22902 
  Attributes:
22903 
   - success
22904 
  """
22905 
 
22906 
  thrift_spec = (
22907 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22908 
  )
22909 
 
22910 
  def __init__(self, success=None,):
22911 
    self.success = success
22912 
 
22913 
  def read(self, iprot):
22914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22916 
      return
22917 
    iprot.readStructBegin()
22918 
    while True:
22919 
      (fname, ftype, fid) = iprot.readFieldBegin()
22920 
      if ftype == TType.STOP:
22921 
        break
22922 
      if fid == 0:
22923 
        if ftype == TType.LIST:
22924 
          self.success = []
22925 
          (_etype537, _size534) = iprot.readListBegin()
22926 
          for _i538 in xrange(_size534):
22927 
            _elem539 = SnapdealItemDetails()
22928 
            _elem539.read(iprot)
22929 
            self.success.append(_elem539)
22930 
          iprot.readListEnd()
22931 
        else:
22932 
          iprot.skip(ftype)
22933 
      else:
22934 
        iprot.skip(ftype)
22935 
      iprot.readFieldEnd()
22936 
    iprot.readStructEnd()
22937 
 
22938 
  def write(self, oprot):
22939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22941 
      return
22942 
    oprot.writeStructBegin('searchSnapdealItems_result')
22943 
    if self.success is not None:
22944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22946 
      for iter540 in self.success:
22947 
        iter540.write(oprot)
22948 
      oprot.writeListEnd()
22949 
      oprot.writeFieldEnd()
22950 
    oprot.writeFieldStop()
22951 
    oprot.writeStructEnd()
22952 
 
22953 
  def validate(self):
22954 
    return
22955 
 
22956 
 
22957 
  def __repr__(self):
22958 
    L = ['%s=%r' % (key, value)
22959 
      for key, value in self.__dict__.iteritems()]
22960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22961 
 
22962 
  def __eq__(self, other):
22963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22964 
 
22965 
  def __ne__(self, other):
22966 
    return not (self == other)
22967 
 
22968 
class getCountForSnapdealItems_args:
22969 
 
22970 
  thrift_spec = (
22971 
  )
22972 
 
22973 
  def read(self, iprot):
22974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22976 
      return
22977 
    iprot.readStructBegin()
22978 
    while True:
22979 
      (fname, ftype, fid) = iprot.readFieldBegin()
22980 
      if ftype == TType.STOP:
22981 
        break
22982 
      else:
22983 
        iprot.skip(ftype)
22984 
      iprot.readFieldEnd()
22985 
    iprot.readStructEnd()
22986 
 
22987 
  def write(self, oprot):
22988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22990 
      return
22991 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
22992 
    oprot.writeFieldStop()
22993 
    oprot.writeStructEnd()
22994 
 
22995 
  def validate(self):
22996 
    return
22997 
 
22998 
 
22999 
  def __repr__(self):
23000 
    L = ['%s=%r' % (key, value)
23001 
      for key, value in self.__dict__.iteritems()]
23002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23003 
 
23004 
  def __eq__(self, other):
23005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23006 
 
23007 
  def __ne__(self, other):
23008 
    return not (self == other)
23009 
 
23010 
class getCountForSnapdealItems_result:
23011 
  """
23012 
  Attributes:
23013 
   - success
23014 
  """
23015 
 
23016 
  thrift_spec = (
23017 
    (0, TType.I64, 'success', None, None, ), # 0
23018 
  )
23019 
 
23020 
  def __init__(self, success=None,):
23021 
    self.success = success
23022 
 
23023 
  def read(self, iprot):
23024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23026 
      return
23027 
    iprot.readStructBegin()
23028 
    while True:
23029 
      (fname, ftype, fid) = iprot.readFieldBegin()
23030 
      if ftype == TType.STOP:
23031 
        break
23032 
      if fid == 0:
23033 
        if ftype == TType.I64:
23034 
          self.success = iprot.readI64();
23035 
        else:
23036 
          iprot.skip(ftype)
23037 
      else:
23038 
        iprot.skip(ftype)
23039 
      iprot.readFieldEnd()
23040 
    iprot.readStructEnd()
23041 
 
23042 
  def write(self, oprot):
23043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23045 
      return
23046 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23047 
    if self.success is not None:
23048 
      oprot.writeFieldBegin('success', TType.I64, 0)
23049 
      oprot.writeI64(self.success)
23050 
      oprot.writeFieldEnd()
23051 
    oprot.writeFieldStop()
23052 
    oprot.writeStructEnd()
23053 
 
23054 
  def validate(self):
23055 
    return
23056 
 
23057 
 
23058 
  def __repr__(self):
23059 
    L = ['%s=%r' % (key, value)
23060 
      for key, value in self.__dict__.iteritems()]
23061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23062 
 
23063 
  def __eq__(self, other):
23064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23065 
 
23066 
  def __ne__(self, other):
23067 
    return not (self == other)
23068 
 
23069 
class getSnapdealSearchResultCount_args:
23070 
  """
23071 
  Attributes:
23072 
   - searchTerm
23073 
  """
23074 
 
23075 
  thrift_spec = (
23076 
    None, # 0
23077 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23078 
  )
23079 
 
23080 
  def __init__(self, searchTerm=None,):
23081 
    self.searchTerm = searchTerm
23082 
 
23083 
  def read(self, iprot):
23084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23086 
      return
23087 
    iprot.readStructBegin()
23088 
    while True:
23089 
      (fname, ftype, fid) = iprot.readFieldBegin()
23090 
      if ftype == TType.STOP:
23091 
        break
23092 
      if fid == 1:
23093 
        if ftype == TType.LIST:
23094 
          self.searchTerm = []
23095 
          (_etype544, _size541) = iprot.readListBegin()
23096 
          for _i545 in xrange(_size541):
23097 
            _elem546 = iprot.readString();
23098 
            self.searchTerm.append(_elem546)
23099 
          iprot.readListEnd()
23100 
        else:
23101 
          iprot.skip(ftype)
23102 
      else:
23103 
        iprot.skip(ftype)
23104 
      iprot.readFieldEnd()
23105 
    iprot.readStructEnd()
23106 
 
23107 
  def write(self, oprot):
23108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23110 
      return
23111 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23112 
    if self.searchTerm is not None:
23113 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23114 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23115 
      for iter547 in self.searchTerm:
23116 
        oprot.writeString(iter547)
23117 
      oprot.writeListEnd()
23118 
      oprot.writeFieldEnd()
23119 
    oprot.writeFieldStop()
23120 
    oprot.writeStructEnd()
23121 
 
23122 
  def validate(self):
23123 
    return
23124 
 
23125 
 
23126 
  def __repr__(self):
23127 
    L = ['%s=%r' % (key, value)
23128 
      for key, value in self.__dict__.iteritems()]
23129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23130 
 
23131 
  def __eq__(self, other):
23132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23133 
 
23134 
  def __ne__(self, other):
23135 
    return not (self == other)
23136 
 
23137 
class getSnapdealSearchResultCount_result:
23138 
  """
23139 
  Attributes:
23140 
   - success
23141 
  """
23142 
 
23143 
  thrift_spec = (
23144 
    (0, TType.I64, 'success', None, None, ), # 0
23145 
  )
23146 
 
23147 
  def __init__(self, success=None,):
23148 
    self.success = success
23149 
 
23150 
  def read(self, iprot):
23151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23153 
      return
23154 
    iprot.readStructBegin()
23155 
    while True:
23156 
      (fname, ftype, fid) = iprot.readFieldBegin()
23157 
      if ftype == TType.STOP:
23158 
        break
23159 
      if fid == 0:
23160 
        if ftype == TType.I64:
23161 
          self.success = iprot.readI64();
23162 
        else:
23163 
          iprot.skip(ftype)
23164 
      else:
23165 
        iprot.skip(ftype)
23166 
      iprot.readFieldEnd()
23167 
    iprot.readStructEnd()
23168 
 
23169 
  def write(self, oprot):
23170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23172 
      return
23173 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23174 
    if self.success is not None:
23175 
      oprot.writeFieldBegin('success', TType.I64, 0)
23176 
      oprot.writeI64(self.success)
23177 
      oprot.writeFieldEnd()
23178 
    oprot.writeFieldStop()
23179 
    oprot.writeStructEnd()
23180 
 
23181 
  def validate(self):
23182 
    return
23183 
 
23184 
 
23185 
  def __repr__(self):
23186 
    L = ['%s=%r' % (key, value)
23187 
      for key, value in self.__dict__.iteritems()]
23188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23189 
 
23190 
  def __eq__(self, other):
23191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23192 
 
23193 
  def __ne__(self, other):
23194 
    return not (self == other)